RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity

Switch to std::is_trivially_move_constructible and std::is_trivially_copy_constructible

Browse Source 
Differential Revision: https://reviews.llvm.org/D92543
This commit is contained in:
Fangrui Song 2020-12-03 09:15:40 -08:00
parent b51993db92
commit f6492fea1c
6 changed files with 5 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/ADT/FunctionExtras.h
View File

@ -57,7 +57,7 @@ namespace detail {
template <typename T>
using EnableIfTrivial =
std::enable_if_t<llvm::is_trivially_move_constructible<T>::value &&
std::enable_if_t<std::is_trivially_move_constructible<T>::value &&
std::is_trivially_destructible<T>::value>;
template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
@ -83,8 +83,8 @@ protected:
template <typename T>
using AdjustedParamT = typename std::conditional<
!std::is_reference<T>::value &&
llvm::is_trivially_copy_constructible<T>::value &&
llvm::is_trivially_move_constructible<T>::value &&
std::is_trivially_copy_constructible<T>::value &&
std::is_trivially_move_constructible<T>::value &&
IsSizeLessThanThresholdT<T>::value,
T, T &>::type;

4
include/llvm/ADT/SmallVector.h
View File

@ -278,8 +278,8 @@ public:
/// copy these types with memcpy, there is no way for the type to observe this.
/// This catches the important case of std::pair<POD, POD>, which is not
/// trivially assignable.
template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
(is_trivially_move_constructible<T>::value) &&
template <typename T, bool = (std::is_trivially_copy_constructible<T>::value) &&
(std::is_trivially_move_constructible<T>::value) &&
std::is_trivially_destructible<T>::value>
class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
protected:

37
include/llvm/Support/type_traits.h
View File

@ -70,20 +70,6 @@ struct const_pointer_or_const_ref<T,
};
namespace detail {
/// Internal utility to detect trivial copy construction.
template<typename T> union copy_construction_triviality_helper {
T t;
copy_construction_triviality_helper() = default;
copy_construction_triviality_helper(const copy_construction_triviality_helper&) = default;
~copy_construction_triviality_helper() = default;
};
/// Internal utility to detect trivial move construction.
template<typename T> union move_construction_triviality_helper {
T t;
move_construction_triviality_helper() = default;
move_construction_triviality_helper(move_construction_triviality_helper&&) = default;
~move_construction_triviality_helper() = default;
};
template<class T>
union trivial_helper {
@ -92,29 +78,6 @@ union trivial_helper {
} // end namespace detail
/// An implementation of `std::is_trivially_copy_constructible` since we have
/// users with STLs that don't yet include it.
template <typename T>
struct is_trivially_copy_constructible
: std::is_copy_constructible<
::llvm::detail::copy_construction_triviality_helper<T>> {};
template <typename T>
struct is_trivially_copy_constructible<T &> : std::true_type {};
template <typename T>
struct is_trivially_copy_constructible<T &&> : std::false_type {};
/// An implementation of `std::is_trivially_move_constructible` since we have
/// users with STLs that don't yet include it.
template <typename T>
struct is_trivially_move_constructible
: std::is_move_constructible<
::llvm::detail::move_construction_triviality_helper<T>> {};
template <typename T>
struct is_trivially_move_constructible<T &> : std::true_type {};
template <typename T>
struct is_trivially_move_constructible<T &&> : std::true_type {};
template <typename T>
struct is_copy_assignable {
template<class F>

1
unittests/Support/CMakeLists.txt
View File

@ -80,7 +80,6 @@ add_llvm_unittest(SupportTests
TimerTest.cpp
ToolOutputFileTest.cpp
TypeNameTest.cpp
TypeTraitsTest.cpp
TrailingObjectsTest.cpp
TrigramIndexTest.cpp
UnicodeTest.cpp

97
unittests/Support/TypeTraitsTest.cpp
View File

@ -1,97 +0,0 @@
//===- TypeTraitsTest.cpp -------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/type_traits.h"
#include "gtest/gtest.h"
namespace {
// Compile-time tests using static assert.
namespace triviality {
// Helper for compile time checking trivially copy constructible and trivially
// move constructible type traits.
template <typename T, bool IsTriviallyCopyConstructible,
bool IsTriviallyMoveConstructible>
void TrivialityTester() {
static_assert(llvm::is_trivially_copy_constructible<T>::value ==
IsTriviallyCopyConstructible,
"Mismatch in expected trivial copy construction!");
static_assert(llvm::is_trivially_move_constructible<T>::value ==
IsTriviallyMoveConstructible,
"Mismatch in expected trivial move construction!");
#if defined(_LIBCPP_VERSION) || defined(_MSC_VER)
// On compilers with support for the standard traits, make sure they agree.
static_assert(std::is_trivially_copy_constructible<T>::value ==
IsTriviallyCopyConstructible,
"Mismatch in expected trivial copy construction!");
static_assert(std::is_trivially_move_constructible<T>::value ==
IsTriviallyMoveConstructible,
"Mismatch in expected trivial move construction!");
#endif
}
template void TrivialityTester<int, true, true>();
template void TrivialityTester<void *, true, true>();
template void TrivialityTester<int &, true, true>();
template void TrivialityTester<int &&, false, true>();
struct X {};
struct Y {
Y(const Y &);
};
struct Z {
Z(const Z &);
Z(Z &&);
};
struct A {
A(const A &) = default;
A(A &&);
};
struct B {
B(const B &);
B(B &&) = default;
};
template void TrivialityTester<X, true, true>();
template void TrivialityTester<Y, false, false>();
template void TrivialityTester<Z, false, false>();
template void TrivialityTester<A, true, false>();
template void TrivialityTester<B, false, true>();
template void TrivialityTester<Z &, true, true>();
template void TrivialityTester<A &, true, true>();
template void TrivialityTester<B &, true, true>();
template void TrivialityTester<Z &&, false, true>();
template void TrivialityTester<A &&, false, true>();
template void TrivialityTester<B &&, false, true>();
TEST(Triviality, Tester) {
TrivialityTester<int, true, true>();
TrivialityTester<void *, true, true>();
TrivialityTester<int &, true, true>();
TrivialityTester<int &&, false, true>();
TrivialityTester<X, true, true>();
TrivialityTester<Y, false, false>();
TrivialityTester<Z, false, false>();
TrivialityTester<A, true, false>();
TrivialityTester<B, false, true>();
TrivialityTester<Z &, true, true>();
TrivialityTester<A &, true, true>();
TrivialityTester<B &, true, true>();
TrivialityTester<Z &&, false, true>();
TrivialityTester<A &&, false, true>();
TrivialityTester<B &&, false, true>();
}
} // namespace triviality
} // end anonymous namespace

1
utils/gn/secondary/llvm/unittests/Support/BUILD.gn
View File

@ -85,7 +85,6 @@ unittest("SupportTests") {
"TrailingObjectsTest.cpp",
"TrigramIndexTest.cpp",
"TypeNameTest.cpp",
"TypeTraitsTest.cpp",
"UnicodeTest.cpp",
"VersionTupleTest.cpp",
"VirtualFileSystemTest.cpp",