6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 19:31:58 +00:00
Code Issues Projects Releases Wiki Activity

SmallVector: support resize(N) with move-only types

Browse Source 
Unfortunately there's no way to elegantly do this with pre-canned
algorithms. Using a generating iterator doesn't work because you default
construct for each element, then move construct into the actual slot
(bad for copy but non-movable types, and a little unneeded overhead even
in the move-only case), so just write it out manually.

This solution isn't exception safe (if one of the element's ctors calls
we don't fall back, destroy the constructed elements, and throw on -
which std::uninitialized_fill does do) but SmallVector (and LLVM) isn't
exception safe anyway.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210495 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Blaikie 2014-06-09 22:26:20 +00:00
parent 8e38e86266
commit 78b4fd3a4b
2 changed files with 32 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -380,7 +380,8 @@ public:
} else if (N > this->size()) { } else if (N > this->size()) {
if (this->capacity() < N) if (this->capacity() < N)
this->grow(N); this->grow(N);
std::uninitialized_fill(this->end(), this->begin()+N, T()); for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
new (&*I) T();
this->setEnd(this->begin()+N); this->setEnd(this->begin()+N);
} }
} }

34
unittests/ADT/SmallVectorTest.cpp
View File

@ -139,6 +139,19 @@ int Constructable::numAssignmentCalls;
int Constructable::numCopyAssignmentCalls; int Constructable::numCopyAssignmentCalls;
int Constructable::numMoveAssignmentCalls; int Constructable::numMoveAssignmentCalls;
struct NonCopyable {
NonCopyable() {}
NonCopyable(NonCopyable &&) {}
NonCopyable &operator=(NonCopyable &&) { return *this; }
NonCopyable(const NonCopyable &) = delete;
NonCopyable &operator=(const NonCopyable &) = delete;
};
LLVM_ATTRIBUTE_USED void CompileTest() {
SmallVector<NonCopyable, 0> V;
V.resize(42);
}
// Test fixture class // Test fixture class
template <typename VectorT> template <typename VectorT>
class SmallVectorTest : public testing::Test { class SmallVectorTest : public testing::Test {
@ -277,13 +290,26 @@ TYPED_TEST(SmallVectorTest, ResizeGrowTest) {
this->theVector.resize(2); this->theVector.resize(2);
// The extra constructor/destructor calls come from the temporary object used EXPECT_EQ(2, Constructable::getNumConstructorCalls());
// to initialize the contents of the resized array (via copy construction). EXPECT_EQ(0, Constructable::getNumDestructorCalls());
EXPECT_EQ(3, Constructable::getNumConstructorCalls());
EXPECT_EQ(1, Constructable::getNumDestructorCalls());
EXPECT_EQ(2u, this->theVector.size()); EXPECT_EQ(2u, this->theVector.size());
} }
TYPED_TEST(SmallVectorTest, ResizeWithElementsTest) {
this->theVector.resize(2);
Constructable::reset();
this->theVector.resize(4);
size_t Ctors = Constructable::getNumConstructorCalls();
EXPECT_TRUE(Ctors == 2 || Ctors == 4);
size_t MoveCtors = Constructable::getNumMoveConstructorCalls();
EXPECT_TRUE(MoveCtors == 0 || MoveCtors == 2);
size_t Dtors = Constructable::getNumDestructorCalls();
EXPECT_TRUE(Dtors == 0 || Dtors == 2);
}
// Resize with fill value. // Resize with fill value.
TYPED_TEST(SmallVectorTest, ResizeFillTest) { TYPED_TEST(SmallVectorTest, ResizeFillTest) {
SCOPED_TRACE("ResizeFillTest"); SCOPED_TRACE("ResizeFillTest");