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

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

275 lines
6.1 KiB
CMake
Raw Normal View History

Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
set(files
__bit_reference
__bsd_locale_defaults.h
__bsd_locale_fallbacks.h
[libc++] Install the missing header __errc Summary: Omitted from D41347. Reviewers: EricWF Subscribers: mgorny, christof, ldionne, cfe-commits Differential Revision: https://reviews.llvm.org/D48864 llvm-svn: 336165
2018-07-03 12:01:44 +08:00
__errc
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
__debug
__functional_03
__functional_base
__functional_base_03
__hash_table
__libcpp_version
__locale
__mutex_base
First half of C++17's splicing maps and sets This commit adds a node handle type, (located in __node_handle), and adds extract() and insert() members to all map and set types, as well as their implementations in __tree and __hash_table. The second half of this feature is adding merge() members, which splice nodes in bulk from one container into another. This will be committed in a follow-up. Differential revision: https://reviews.llvm.org/D46845 llvm-svn: 338472
2018-08-01 09:33:38 +08:00
__node_handle
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
__nullptr
__split_buffer
__sso_allocator
__std_stream
__string
__threading_support
__tree
__tuple
__undef_macros
algorithm
any
array
atomic
[libc++] Implementation of C++20's P1135R6 for libcxx Differential Revision: https://reviews.llvm.org/D68480
2020-02-18 22:58:34 +08:00
barrier
Recommit r339943 - Establish the <bit> header. NFC yet. Reviewed as https://reviews.llvm.org/D50815 - with a fix for the sanitizer bots llvm-svn: 340045
2018-08-18 00:07:48 +08:00
bit
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
bitset
cassert
ccomplex
cctype
cerrno
cfenv
cfloat
[libc++][C++17] Elementary string conversions for integral types Summary: Major QoI considerations: - The facility is backported to C++14, same as libstdc++. - Efforts have been made to minimize the header dependencies. - The design is friendly to the uses of MSVC intrinsics (`__emulu`, `_umul128`, `_BitScanForward`, `_BitScanForward64`) but not implemented; future contributions are welcome. Thanks to Milo Yip for contributing the implementation of `__u64toa` and `__u32toa`. References: https://wg21.link/p0067r5 https://wg21.link/p0682r1 Reviewers: mclow.lists, EricWF Reviewed By: mclow.lists Subscribers: ldionne, Quuxplusone, christof, mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D41458 llvm-svn: 338479
2018-08-01 10:38:30 +08:00
charconv
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
chrono
cinttypes
ciso646
climits
clocale
cmath
codecvt
compare
complex
complex.h
[libcxx] Adds [concept.same] Patch from Christopher Di Bella (cjdb@google.com) Reviewed as https://reviews.llvm.org/D74291 Adds `std::same_as` to libc++. Since there aren't clang-format rules for //requires-expressions//, I'll need to disable the formatter in certain areas.
2020-04-09 06:00:13 +08:00
concepts
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
condition_variable
csetjmp
csignal
cstdarg
cstdbool
cstddef
cstdint
cstdio
cstdlib
cstring
ctgmath
ctime
ctype.h
cwchar
cwctype
deque
errno.h
exception
[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
execution
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
experimental/__config
experimental/__memory
experimental/algorithm
experimental/coroutine
experimental/deque
experimental/filesystem
experimental/forward_list
experimental/functional
experimental/iterator
experimental/list
experimental/map
experimental/memory_resource
experimental/propagate_const
experimental/regex
experimental/set
experimental/simd
experimental/string
experimental/type_traits
experimental/unordered_map
experimental/unordered_set
experimental/utility
experimental/vector
ext/__hash
ext/hash_map
ext/hash_set
Add fenv.h header Summary: Some implementations of fenv.h use macros to define the functions they provide. This can cause problems when `std::fegetround()` is spelled in source. This patch adds a `fenv.h` header to libc++ for the sole purpose of turning those macros into real functions. Reviewers: rsmith, mclow.lists, ldionne Reviewed By: rsmith Subscribers: mgorny, christof, libcxx-commits Differential Revision: https://reviews.llvm.org/D57729 llvm-svn: 353767
2019-02-12 07:47:19 +08:00
fenv.h
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
filesystem
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
float.h
forward_list
fstream
functional
future
initializer_list
inttypes.h
iomanip
ios
iosfwd
iostream
istream
iterator
[libc++] Implementation of C++20's P1135R6 for libcxx Differential Revision: https://reviews.llvm.org/D68480
2020-02-18 22:58:34 +08:00
latch
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
limits
limits.h
list
locale
locale.h
map
math.h
memory
module.modulemap
mutex
new
[libc++] Implement <numbers> Summary: Constants have 33 significant decimal digits for IEEE 754 128-bit floating-point numbers. Reviewers: ldionne, #libc, EricWF, zoecarver, curdeius Reviewed By: ldionne, #libc, curdeius Differential Revision: https://reviews.llvm.org/D77505
2020-06-19 15:13:33 +08:00
numbers
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
numeric
optional
ostream
queue
random
ratio
regex
scoped_allocator
[libc++] Implementation of C++20's P1135R6 for libcxx Differential Revision: https://reviews.llvm.org/D68480
2020-02-18 22:58:34 +08:00
semaphore
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
set
setjmp.h
shared_mutex
Implement <span>. Reviewed as https://reviews.llvm.org/D49338 llvm-svn: 337804
2018-07-24 11:01:02 +08:00
span
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
sstream
stack
stdbool.h
stddef.h
stdexcept
stdint.h
stdio.h
stdlib.h
streambuf
string
string.h
string_view
strstream
system_error
tgmath.h
thread
tuple
type_traits
typeindex
typeinfo
unordered_map
unordered_set
utility
valarray
variant
vector
version
wchar.h
wctype.h
)
if(LIBCXX_INSTALL_SUPPORT_HEADERS)
set(files
${files}
support/android/locale_bionic.h
support/fuchsia/xlocale.h
support/ibm/limits.h
support/ibm/locale_mgmt_aix.h
support/ibm/support.h
support/ibm/xlocale.h
support/musl/xlocale.h
support/newlib/xlocale.h
support/solaris/floatingpoint.h
support/solaris/wchar.h
support/solaris/xlocale.h
support/win32/limits_msvc_win32.h
support/win32/locale_win32.h
support/xlocale/__nop_locale_mgmt.h
support/xlocale/__posix_l_fallback.h
support/xlocale/__strtonum_fallback.h
)
Add the CMakeLists.txt that was missed in r194825 llvm-svn: 194838
2013-11-16 02:34:43 +08:00
endif()
[libcxx] Capture configuration information when installing the libc++ headers Summary: Hi all, This patch is a successor to D11963. However it has changed dramatically and I felt it would be best to start a new review thread. Please read the design documentation added in this patch for a description of how it works. Reviewers: mclow.lists, danalbert, jroelofs, EricWF Subscribers: vkalintiris, rnk, ed, espositofulvio, asl, eugenis, cfe-commits Differential Revision: http://reviews.llvm.org/D13407 llvm-svn: 250235
2015-10-14 06:12:02 +08:00
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
configure_file("__config_site.in"
"${LIBCXX_BINARY_DIR}/__config_site"
@ONLY)
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
# Generate a custom __config header. The new header is created
# by prepending __config_site to the current __config header.
add_custom_command(OUTPUT ${LIBCXX_BINARY_DIR}/__generated_config
COMMAND ${Python3_EXECUTABLE} ${LIBCXX_SOURCE_DIR}/utils/cat_files.py
${LIBCXX_BINARY_DIR}/__config_site
${LIBCXX_SOURCE_DIR}/include/__config
-o ${LIBCXX_BINARY_DIR}/__generated_config
DEPENDS ${LIBCXX_SOURCE_DIR}/include/__config
${LIBCXX_BINARY_DIR}/__config_site
)
# Add a target that executes the generation commands.
add_custom_target(cxx-generated-config ALL
DEPENDS ${LIBCXX_BINARY_DIR}/__generated_config)
if(LIBCXX_HEADER_DIR)
set(output_dir ${LIBCXX_HEADER_DIR}/include/c++/v1)
set(out_files)
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
foreach(f ${files})
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
set(src ${CMAKE_CURRENT_SOURCE_DIR}/${f})
set(dst ${output_dir}/${f})
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
add_custom_command(OUTPUT ${dst}
DEPENDS ${src}
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
COMMENT "Copying CXX header ${f}")
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
list(APPEND out_files ${dst})
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
endforeach()
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
# Copy the generated header as __config into build directory.
set(src ${LIBCXX_BINARY_DIR}/__generated_config)
set(dst ${output_dir}/__config)
add_custom_command(OUTPUT ${dst}
DEPENDS ${src} cxx-generated-config
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
COMMENT "Copying CXX __config")
list(APPEND out_files ${dst})
add_custom_target(generate-cxx-headers DEPENDS ${out_files})
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
[CMake] Use -isystem flag to access libc++ headers This is a partial revert of D62155. Rather than copying libc++ headers into the build directory to be later overwritten by the final headers, use -isystem flag to access libc++ headers during CMake checks. This should address the occasional flake we've seen, especially on Windows builders where CMake fails to overwrite __config with the final version. Differential Revision: https://reviews.llvm.org/D88454
2020-09-29 07:12:48 +08:00
add_library(cxx-headers INTERFACE)
add_dependencies(cxx-headers generate-cxx-headers ${LIBCXX_CXX_ABI_HEADER_TARGET})
[libc++] Use a proper CMake target to represent libc++ headers Instead of having complex logic around how to include the libc++ headers and __config_site, handle that by defining cxx-headers as an INTERFACE library and linking against it. After this patch, linking against cxx-headers is sufficient to get the right __config_site include and include paths for libc++. Differential Revision: https://reviews.llvm.org/D82702
2020-06-27 04:05:55 +08:00
# 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")
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
target_compile_options(cxx-headers INTERFACE /I "${output_dir}")
else()
target_compile_options(cxx-headers INTERFACE -I "${output_dir}")
endif()
# Make sure the generated __config_site header is included when we build the library.
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQUAL "MSVC")
target_compile_options(cxx-headers INTERFACE /FI "${LIBCXX_BINARY_DIR}/__config_site")
[libc++] Use a proper CMake target to represent libc++ headers Instead of having complex logic around how to include the libc++ headers and __config_site, handle that by defining cxx-headers as an INTERFACE library and linking against it. After this patch, linking against cxx-headers is sufficient to get the right __config_site include and include paths for libc++. Differential Revision: https://reviews.llvm.org/D82702
2020-06-27 04:05:55 +08:00
else()
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
target_compile_options(cxx-headers INTERFACE -include "${LIBCXX_BINARY_DIR}/__config_site")
[libc++] Use a proper CMake target to represent libc++ headers Instead of having complex logic around how to include the libc++ headers and __config_site, handle that by defining cxx-headers as an INTERFACE library and linking against it. After this patch, linking against cxx-headers is sufficient to get the right __config_site include and include paths for libc++. Differential Revision: https://reviews.llvm.org/D82702
2020-06-27 04:05:55 +08:00
endif()
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
else()
[CMake] Use -isystem flag to access libc++ headers This is a partial revert of D62155. Rather than copying libc++ headers into the build directory to be later overwritten by the final headers, use -isystem flag to access libc++ headers during CMake checks. This should address the occasional flake we've seen, especially on Windows builders where CMake fails to overwrite __config with the final version. Differential Revision: https://reviews.llvm.org/D88454
2020-09-29 07:12:48 +08:00
add_library(cxx-headers INTERFACE)
[CMake] Copy headers relative to LLVM_BINARY_DIR Summary: This copy phase is only needed for in-tree builds, so we should be copying to the LLVM build directory's include dir instead of the sub-project include dir. Reviewers: bogner, EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D24015 llvm-svn: 280108
2016-08-31 00:51:34 +08:00
endif()
Make headers available in the build directory This essentially re-does r194825 and makes it possible to run clang with libc++ without having to install it, even if you don't have any version of libc++ installed in /usr/. This behaviour broke in r210577/r211629, which fixed pr18681. llvm-svn: 220489
2014-10-24 00:51:12 +08:00
Add option to turn off installation of headers. llvm-svn: 224162
2014-12-13 06:52:58 +08:00
if (LIBCXX_INSTALL_HEADERS)
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
foreach(file ${files})
get_filename_component(dir ${file} DIRECTORY)
install(FILES ${file}
[CMake] Use correct variable as header install prefix This variable is already set in CMakeLists.txt but it wasn't used which means that the headers get installed into a wrong location when the per target runtime directory option is being used. Differential Revision: https://reviews.llvm.org/D49345 llvm-svn: 337118
2018-07-15 12:09:35 +08:00
DESTINATION ${LIBCXX_INSTALL_HEADER_PREFIX}include/c++/v1/${dir}
[CMake] Use -isystem flag to access libc++ headers This is a partial revert of D62155. Rather than copying libc++ headers into the build directory to be later overwritten by the final headers, use -isystem flag to access libc++ headers during CMake checks. This should address the occasional flake we've seen, especially on Windows builders where CMake fails to overwrite __config with the final version. Differential Revision: https://reviews.llvm.org/D88454
2020-09-29 07:12:48 +08:00
COMPONENT cxx-headers
Reland "Use custom command and target to install libc++ headers" Using file(COPY FILE...) has several downsides. Since the file command is only executed at configuration time, any changes to headers made after the initial CMake execution are ignored. This can lead to subtle errors since the just built Clang will be using stale libc++ headers. Furthermore, since the headers are copied prior to executing the build system, this may hide missing dependencies on libc++ from other LLVM components. This changes replaces the use of file(COPY FILE...) command with a custom command and target which addresses all aforementioned issues and matches the implementation already used by other LLVM components that also install headers like Clang builtin headers. Differential Revision: https://reviews.llvm.org/D44773 llvm-svn: 334468
2018-06-12 11:10:02 +08:00
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
)
endforeach()
[libcxx] Capture configuration information when installing the libc++ headers Summary: Hi all, This patch is a successor to D11963. However it has changed dramatically and I felt it would be best to start a new review thread. Please read the design documentation added in this patch for a description of how it works. Reviewers: mclow.lists, danalbert, jroelofs, EricWF Subscribers: vkalintiris, rnk, ed, espositofulvio, asl, eugenis, cfe-commits Differential Revision: http://reviews.llvm.org/D13407 llvm-svn: 250235
2015-10-14 06:12:02 +08:00
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
# Install the generated header as __config.
install(FILES ${LIBCXX_BINARY_DIR}/__generated_config
[libc++] Always generate a __config_site header Before this patch, the __config_site header was only generated when at least one __config_site macro needed to be defined. This lead to two different code paths in how libc++ is configured, depending on whether a __config_site header was generated or not. After this patch, the __config_site is always generated, but it can be empty in case there are no macros to define in it. More context on why this change is important -------------------------------------------- In addition to being confusing, this double-code-path situation lead to broken code being checked in undetected in 2405bd689815, which introduced the LIBCXX_HAS_MERGED_TYPEINFO_NAMES_DEFAULT CMake setting. Specifically, the _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT <__config_site> macro was supposed NOT to be defined unless LIBCXX_HAS_MERGED_TYPEINFO_NAMES_DEFAULT was specified explicitly on the CMake command line. Instead, what happened is that it was defined to 0 if it wasn't specified explicitly and a <__config_site> header was generated. And defining that macro to 0 had the important effect of using the non-unique RTTI comparison implementation, which changes the ABI. This change in behavior wasn't noticed because the <__config_site> header is not generated by default. However, the Apple configuration does cause a <__config_site> header to be generated, which lead to the wrong RTTI implementation being used, and to https://llvm.org/PR45549. We came close to an ABI break in the dylib, but were saved due to a downstream-only change that overrode the decision of the <__config_site> for the purpose of RTTI comparisons in libc++abi. This is an incredible luck that we should not rely on ever again. While the problem itself was fixed with 2464d8135e2a by setting LIBCXX_HAS_MERGED_TYPEINFO_NAMES_DEFAULT explicitly in the Apple CMake cache and then in d0fcdcd28f95 by making the setting less brittle, the point still is that we should have had a single code path from the beginning. Unlike most normal libraries, the macros that configure libc++ are really complex, there's a lot of them and they control important properties of the C++ runtime. There must be a single code path for that, and it must be simple and robust. Differential Revision: https://reviews.llvm.org/D80927
2020-05-16 02:54:27 +08:00
DESTINATION ${LIBCXX_INSTALL_HEADER_PREFIX}include/c++/v1
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
RENAME __config
[CMake] Use -isystem flag to access libc++ headers This is a partial revert of D62155. Rather than copying libc++ headers into the build directory to be later overwritten by the final headers, use -isystem flag to access libc++ headers during CMake checks. This should address the occasional flake we've seen, especially on Windows builders where CMake fails to overwrite __config with the final version. Differential Revision: https://reviews.llvm.org/D88454
2020-09-29 07:12:48 +08:00
COMPONENT cxx-headers)
[CMake] Create a separate install target for libcxx headers This change doesn't impact the behavior of the install-libcxx target which installs whichever libcxx components you build, it just adds a separate target to just install the headers. llvm-svn: 268124
2016-04-30 06:17:15 +08:00
if (NOT CMAKE_CONFIGURATION_TYPES)
[CMake] Use -isystem flag to access libc++ headers This is a partial revert of D62155. Rather than copying libc++ headers into the build directory to be later overwritten by the final headers, use -isystem flag to access libc++ headers during CMake checks. This should address the occasional flake we've seen, especially on Windows builders where CMake fails to overwrite __config with the final version. Differential Revision: https://reviews.llvm.org/D88454
2020-09-29 07:12:48 +08:00
add_custom_target(install-cxx-headers
[runtimes] Revert the libc++ __config_site change This is a massive revert of the following commits (from most revent to oldest): 2b9b7b5775a1d8fcd7aa5abaa8fc0bc303434f1a. 529ac33197f6408952ae995075ac5e2dc5287e81 28270234f1478047e35879f4ba8838b47edfcc14 69c2087283cf7b17ca75f69daebf4ffc158b754a b5aa67446e01bd277727b05710a42e69ac41e74b 5d796645d6c8cadeb003715c33e231a8ba05b6de After checking-in the __config_site change, a lot of things started breaking due to widespread reliance on various aspects of libc++'s build, notably the fact that we can include the headers from the source tree, but also reliance on various "internal" CMake variables used by the runtimes build and compiler-rt. These were unintended consequences of the change, and after two days, we still haven't restored all the bots to being green. Instead, now that I understand what specific areas this will blow up in, I should be able to chop up the patch into smaller ones that are easier to digest. See https://reviews.llvm.org/D89041 for more details on this adventure.
2020-10-23 21:32:50 +08:00
DEPENDS cxx-headers cxx-generated-config
[CMake] Create a separate install target for libcxx headers This change doesn't impact the behavior of the install-libcxx target which installs whichever libcxx components you build, it just adds a separate target to just install the headers. llvm-svn: 268124
2016-04-30 06:17:15 +08:00
COMMAND "${CMAKE_COMMAND}"
[CMake] Use -isystem flag to access libc++ headers This is a partial revert of D62155. Rather than copying libc++ headers into the build directory to be later overwritten by the final headers, use -isystem flag to access libc++ headers during CMake checks. This should address the occasional flake we've seen, especially on Windows builders where CMake fails to overwrite __config with the final version. Differential Revision: https://reviews.llvm.org/D88454
2020-09-29 07:12:48 +08:00
-DCMAKE_INSTALL_COMPONENT=cxx-headers
[CMake] Create a separate install target for libcxx headers This change doesn't impact the behavior of the install-libcxx target which installs whichever libcxx components you build, it just adds a separate target to just install the headers. llvm-svn: 268124
2016-04-30 06:17:15 +08:00
-P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
[libc++] Create install-stripped targets LLVM is gaining install-*-stripped targets to perform stripped installs, and in order for this to be useful for install-distribution, all potential distribution components should have stripped installation targets. LLVM has a function to create these install targets, but since we can't use LLVM CMake functions in libc++, let's do it manually. Differential Revision: https://reviews.llvm.org/D40680 llvm-svn: 319959
2017-12-07 05:03:42 +08:00
# Stripping is a no-op for headers
[CMake] Use -isystem flag to access libc++ headers This is a partial revert of D62155. Rather than copying libc++ headers into the build directory to be later overwritten by the final headers, use -isystem flag to access libc++ headers during CMake checks. This should address the occasional flake we've seen, especially on Windows builders where CMake fails to overwrite __config with the final version. Differential Revision: https://reviews.llvm.org/D88454
2020-09-29 07:12:48 +08:00
add_custom_target(install-cxx-headers-stripped DEPENDS install-cxx-headers)
[libcxx] Capture configuration information when installing the libc++ headers Summary: Hi all, This patch is a successor to D11963. However it has changed dramatically and I felt it would be best to start a new review thread. Please read the design documentation added in this patch for a description of how it works. Reviewers: mclow.lists, danalbert, jroelofs, EricWF Subscribers: vkalintiris, rnk, ed, espositofulvio, asl, eugenis, cfe-commits Differential Revision: http://reviews.llvm.org/D13407 llvm-svn: 250235
2015-10-14 06:12:02 +08:00
endif()
Add option to turn off installation of headers. llvm-svn: 224162
2014-12-13 06:52:58 +08:00
endif()