[llvm] r353940 - Revert r353927
Serge Guelton via llvm-commits
llvm-commits at lists.llvm.org
Wed Feb 13 03:35:45 PST 2019
Author: serge_sans_paille
Date: Wed Feb 13 03:35:45 2019
New Revision: 353940
URL: http://llvm.org/viewvc/llvm-project?rev=353940&view=rev
Log:
Revert r353927
Modified:
llvm/trunk/include/llvm/ADT/Optional.h
llvm/trunk/unittests/ADT/OptionalTest.cpp
Modified: llvm/trunk/include/llvm/ADT/Optional.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/Optional.h?rev=353940&r1=353939&r2=353940&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/Optional.h (original)
+++ llvm/trunk/include/llvm/ADT/Optional.h Wed Feb 13 03:35:45 2019
@@ -29,77 +29,36 @@ namespace llvm {
class raw_ostream;
namespace optional_detail {
-
/// Storage for any type.
-//
-template <class T> struct OptionalTrivialStorage {
+template <typename T, bool = is_trivially_copyable<T>::value> struct OptionalStorage {
AlignedCharArrayUnion<T> storage;
bool hasVal = false;
- OptionalTrivialStorage() = default;
- OptionalTrivialStorage(OptionalTrivialStorage const &) = default;
- OptionalTrivialStorage(OptionalTrivialStorage &&) = default;
- OptionalTrivialStorage &operator=(OptionalTrivialStorage const &) = default;
- OptionalTrivialStorage &operator=(OptionalTrivialStorage &&) = default;
- ~OptionalTrivialStorage() = default;
-
- OptionalTrivialStorage(const T &y) : hasVal(true) {
- new (storage.buffer) T(y);
- }
- OptionalTrivialStorage(T &&y) : hasVal(true) {
- new (storage.buffer) T(std::move(y));
- }
-
- OptionalTrivialStorage &operator=(const T &y) {
- new (storage.buffer) T(y);
- hasVal = true;
- return *this;
- }
- OptionalTrivialStorage &operator=(T &&y) {
- new (storage.buffer) T(std::move(y));
- hasVal = true;
- return *this;
- }
-
- T *getPointer() {
- assert(hasVal);
- return reinterpret_cast<T *>(storage.buffer);
- }
- const T *getPointer() const {
- assert(hasVal);
- return reinterpret_cast<const T *>(storage.buffer);
- }
- void reset() { hasVal = false; }
-};
-
-template <typename T> struct OptionalStorage : OptionalTrivialStorage<T> {
OptionalStorage() = default;
- OptionalStorage(const T &y) : OptionalTrivialStorage<T>(y) {}
- OptionalStorage(T &&y) : OptionalTrivialStorage<T>(std::move(y)) {}
-
- OptionalStorage(const OptionalStorage &O) : OptionalTrivialStorage<T>() {
- this->hasVal = O.hasVal;
- if (this->hasVal)
- new (this->storage.buffer) T(*O.getPointer());
+ OptionalStorage(const T &y) : hasVal(true) { new (storage.buffer) T(y); }
+ OptionalStorage(const OptionalStorage &O) : hasVal(O.hasVal) {
+ if (hasVal)
+ new (storage.buffer) T(*O.getPointer());
}
-
- OptionalStorage(OptionalStorage &&O) : OptionalTrivialStorage<T>() {
- this->hasVal = O.hasVal;
+ OptionalStorage(T &&y) : hasVal(true) {
+ new (storage.buffer) T(std::forward<T>(y));
+ }
+ OptionalStorage(OptionalStorage &&O) : hasVal(O.hasVal) {
if (O.hasVal) {
- new (this->storage.buffer) T(std::move(*O.getPointer()));
+ new (storage.buffer) T(std::move(*O.getPointer()));
}
}
OptionalStorage &operator=(T &&y) {
- if (this->hasVal)
- *this->getPointer() = std::move(y);
+ if (hasVal)
+ *getPointer() = std::move(y);
else {
- OptionalTrivialStorage<T>::operator=(std::move(y));
+ new (storage.buffer) T(std::move(y));
+ hasVal = true;
}
return *this;
}
-
OptionalStorage &operator=(OptionalStorage &&O) {
if (!O.hasVal)
reset();
@@ -115,10 +74,11 @@ template <typename T> struct OptionalSto
// requirements (notably: the existence of a default ctor) when implemented
// in that way. Careful SFINAE to avoid such pitfalls would be required.
OptionalStorage &operator=(const T &y) {
- if (this->hasVal)
- *this->getPointer() = y;
+ if (hasVal)
+ *getPointer() = y;
else {
- OptionalTrivialStorage<T>::operator=(y);
+ new (storage.buffer) T(y);
+ hasVal = true;
}
return *this;
}
@@ -133,19 +93,26 @@ template <typename T> struct OptionalSto
~OptionalStorage() { reset(); }
void reset() {
- if (this->hasVal) {
- (*this->getPointer()).~T();
- OptionalTrivialStorage<T>::reset();
+ if (hasVal) {
+ (*getPointer()).~T();
+ hasVal = false;
}
}
+
+ T *getPointer() {
+ assert(hasVal);
+ return reinterpret_cast<T *>(storage.buffer);
+ }
+ const T *getPointer() const {
+ assert(hasVal);
+ return reinterpret_cast<const T *>(storage.buffer);
+ }
};
} // namespace optional_detail
template <typename T> class Optional {
- typename std::conditional<is_trivially_copyable<T>::value,
- optional_detail::OptionalTrivialStorage<T>,
- optional_detail::OptionalStorage<T>>::type Storage;
+ optional_detail::OptionalStorage<T> Storage;
public:
using value_type = T;
Modified: llvm/trunk/unittests/ADT/OptionalTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ADT/OptionalTest.cpp?rev=353940&r1=353939&r2=353940&view=diff
==============================================================================
--- llvm/trunk/unittests/ADT/OptionalTest.cpp (original)
+++ llvm/trunk/unittests/ADT/OptionalTest.cpp Wed Feb 13 03:35:45 2019
@@ -18,12 +18,6 @@ using namespace llvm;
namespace {
-static_assert(llvm::is_trivially_copyable<Optional<int>>::value,
- "trivially copyable");
-
-static_assert(llvm::is_trivially_copyable<Optional<std::array<int, 3>>>::value,
- "trivially copyable");
-
struct NonDefaultConstructible {
static unsigned CopyConstructions;
static unsigned Destructions;
@@ -51,10 +45,6 @@ unsigned NonDefaultConstructible::CopyCo
unsigned NonDefaultConstructible::Destructions = 0;
unsigned NonDefaultConstructible::CopyAssignments = 0;
-static_assert(
- !llvm::is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
- "not trivially copyable");
-
// Test fixture
class OptionalTest : public testing::Test {
};
@@ -213,10 +203,6 @@ struct MultiArgConstructor {
};
unsigned MultiArgConstructor::Destructions = 0;
-static_assert(
- !llvm::is_trivially_copyable<Optional<MultiArgConstructor>>::value,
- "not trivially copyable");
-
TEST_F(OptionalTest, Emplace) {
MultiArgConstructor::ResetCounts();
Optional<MultiArgConstructor> A;
@@ -264,9 +250,6 @@ unsigned MoveOnly::MoveConstructions = 0
unsigned MoveOnly::Destructions = 0;
unsigned MoveOnly::MoveAssignments = 0;
-static_assert(!llvm::is_trivially_copyable<Optional<MoveOnly>>::value,
- "not trivially copyable");
-
TEST_F(OptionalTest, MoveOnlyNull) {
MoveOnly::ResetCounts();
Optional<MoveOnly> O;
@@ -368,9 +351,6 @@ private:
unsigned Immovable::Constructions = 0;
unsigned Immovable::Destructions = 0;
-static_assert(!llvm::is_trivially_copyable<Optional<Immovable>>::value,
- "not trivially copyable");
-
TEST_F(OptionalTest, ImmovableEmplace) {
Optional<Immovable> A;
Immovable::ResetCounts();
More information about the llvm-commits
mailing list