From 9e64837cfea0710ed1a5752db381b4e7f4681844 Mon Sep 17 00:00:00 2001 From: Serge Guelton Date: Tue, 22 Jan 2019 13:48:55 +0000 Subject: [PATCH] Fix llvm::is_trivially_copyable portability issues llvm::is_trivially_copyable portability is verified at compile time using std::is_trivially_copyable as the reference implementation. Unfortunately, the latter is not available on all platforms, so introduce a proper configure check to detect if it is available on the target platform. In a similar manner, std::is_copy_assignable is not fully supported for gcc4.9. Provide a portable (?) implementation instead. Differential Revision: https://reviews.llvm.org/D57018 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@351820 91177308-0d34-0410-b5e6-96231b3b80d8 --- cmake/config-ix.cmake | 9 ++++++++ include/llvm/ADT/PointerIntPair.h | 14 ++++++++++++ include/llvm/Config/config.h.cmake | 3 +++ include/llvm/Support/type_traits.h | 35 +++++++++++++++++++++++++----- 4 files changed, 55 insertions(+), 6 deletions(-) diff --git a/cmake/config-ix.cmake b/cmake/config-ix.cmake index 30ee2b9cbb6..9e9e28f0673 100644 --- a/cmake/config-ix.cmake +++ b/cmake/config-ix.cmake @@ -325,6 +325,15 @@ else() unset(HAVE_FFI_CALL CACHE) endif( LLVM_ENABLE_FFI ) +# Whether we can use std::is_trivially_copyable to verify llvm::is_trivially_copyable. +CHECK_CXX_SOURCE_COMPILES(" +#include +struct T { int val; }; +static_assert(std::is_trivially_copyable::value, \"ok\"); +int main() { return 0;} +" HAVE_STD_IS_TRIVIALLY_COPYABLE) + + # Define LLVM_HAS_ATOMICS if gcc or MSVC atomic builtins are supported. include(CheckAtomic) diff --git a/include/llvm/ADT/PointerIntPair.h b/include/llvm/ADT/PointerIntPair.h index b132de81987..24a2bb67a36 100644 --- a/include/llvm/ADT/PointerIntPair.h +++ b/include/llvm/ADT/PointerIntPair.h @@ -14,6 +14,7 @@ #define LLVM_ADT_POINTERINTPAIR_H #include "llvm/Support/PointerLikeTypeTraits.h" +#include "llvm/Support/type_traits.h" #include #include #include @@ -125,6 +126,19 @@ public: } }; +// Specialize is_trivially_copyable to avoid limitation of llvm::is_trivially_copyable +// when compiled with gcc 4.9. +template +struct is_trivially_copyable> : std::true_type { +#ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE + static_assert(std::is_trivially_copyable>::value, + "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable"); +#endif +}; + + template struct PointerIntPairInfo { static_assert(PtrTraits::NumLowBitsAvailable < diff --git a/include/llvm/Config/config.h.cmake b/include/llvm/Config/config.h.cmake index 03bbd74d6d3..a66d0fa070a 100644 --- a/include/llvm/Config/config.h.cmake +++ b/include/llvm/Config/config.h.cmake @@ -338,6 +338,9 @@ /* Define as the return type of signal handlers (`int' or `void'). */ #cmakedefine RETSIGTYPE ${RETSIGTYPE} +/* Define if std::is_trivially_copyable is supported */ +#cmakedefine HAVE_STD_IS_TRIVIALLY_COPYABLE ${HAVE_STD_IS_TRIVIALLY_COPYABLE} + /* Define to a function implementing stricmp */ #cmakedefine stricmp ${stricmp} diff --git a/include/llvm/Support/type_traits.h b/include/llvm/Support/type_traits.h index b8cf12d03d2..1ceeedd7856 100644 --- a/include/llvm/Support/type_traits.h +++ b/include/llvm/Support/type_traits.h @@ -95,6 +95,7 @@ template union trivial_helper { T t; }; + } // end namespace detail /// An implementation of `std::is_trivially_copy_constructible` since we have @@ -119,6 +120,24 @@ struct is_trivially_move_constructible : std::true_type {}; template struct is_trivially_move_constructible : std::true_type {}; + +template +struct is_copy_assignable { + template + static auto get(F*) -> decltype(std::declval() = std::declval(), std::true_type{}); + static std::false_type get(...); + static constexpr bool value = decltype(get((T*)nullptr))::value; +}; + +template +struct is_move_assignable { + template + static auto get(F*) -> decltype(std::declval() = std::declval(), std::true_type{}); + static std::false_type get(...); + static constexpr bool value = decltype(get((T*)nullptr))::value; +}; + + // An implementation of `std::is_trivially_copyable` since STL version // is not equally supported by all compilers, especially GCC 4.9. // Uniform implementation of this trait is important for ABI compatibility @@ -140,15 +159,15 @@ class is_trivially_copyable { // copy assign static constexpr bool has_trivial_copy_assign = - std::is_copy_assignable>::value; + is_copy_assignable>::value; static constexpr bool has_deleted_copy_assign = - !std::is_copy_assignable::value; + !is_copy_assignable::value; // move assign static constexpr bool has_trivial_move_assign = - std::is_move_assignable>::value; + is_move_assignable>::value; static constexpr bool has_deleted_move_assign = - !std::is_move_assignable::value; + !is_move_assignable::value; // destructor static constexpr bool has_trivial_destructor = @@ -163,10 +182,14 @@ class is_trivially_copyable { (has_deleted_copy_assign || has_trivial_copy_assign) && (has_deleted_copy_constructor || has_trivial_copy_constructor); -#if (__has_feature(is_trivially_copyable) || (defined(__GNUC__) && __GNUC__ >= 5)) - static_assert(value == std::is_trivially_copyable::value, "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable"); +#ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE + static_assert(value == std::is_trivially_copyable::value, + "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable"); #endif }; +template +class is_trivially_copyable : public std::true_type { +}; } // end namespace llvm -- 2.50.1