[libc++] Fix stack_allocator

[EricWF]

Summary

To quote STL the problems with stack allocator are"

"stack_allocator<T, N> is seriously nonconformant to N4582 17.6.3.5 [allocator.requirements].
First, it lacks a rebinding constructor. (The nested "struct rebind" isn't sufficient.)
Second, it lacks templated equality/inequality.
Third, it completely ignores alignment.
Finally, and most severely, the Standard forbids its existence. Allocators are forbidden from returning memory "inside themselves". This requirement is implied by the Standard's requirements for rebinding and equality. It's permitted to return memory from a separate buffer object on the stack, though."

This patch attempts to address all of those issues.

First, instead of storing the buffer inside the allocator I've change stack_allocator to accept the buffer as an argument.

Second, in order to fix rebinding I changed the parameter list from <class T, size_t NumElements> to <class T, size_t NumBytes>. This allows allocator rebinding
between types that have different sizes.

Third, I added copy and rebinding constructors and assignment operators.

And finally I fixed the allocation logic to always return properly aligned storage.

[STL_MSFT]

stack_allocator.h is inconsistent about saying plain size_t or std::size_t.

stack_allocator.h should include type_traits for integral_constant.

stack_allocator.h refers to stack_allocator as both a class and a struct. It should be consistent (not just because MSVC complains).

stack_allocator provides copy assign and convert copy assign. This is unnecessary because it doesn't set any of POCCA/POCMA/POCS. It should probably be non-assignable.

For the same reason, stack_allocator probably shouldn't have a do-nothing swap() overload. It won't be used.

In C++11 land, stack_allocator::allocate() doesn't need "const void* = 0" (because allocator_traits will fill it in). Don't know if you need this for C++03 mode.

stack_allocator equality/inequality probably shouldn't be templated on differing TN/UN, as they aren't rebindable that way.

Why does test_stack_allocator.pass.cpp line 11 have a commented-out path?

There is occasional whitespace damage caused by search-and-replace, e.g. "std::list<int, AllocT >".

Why is test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp 84-85 gaining totally empty braces?

[EricWF]

Why does test_stack_allocator.pass.cpp line 11 have a commented-out path?

Typically tests name the header they test in a comment.

Why is test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp 84-85 gaining totally empty braces?

Mass-translation fatigue. I've removed the empty braces.

All of the comments have been addressed.

[EricWF]

Address @STL_MSFT's comments.

[STL_MSFT]

Seems plausible to me. I haven't tested this against MSVC yet, but at most I expect to have minor issues with space consumption (as we allocate helper objects and sentinel nodes, so any exactly-sized buffers may run out of room). In any event the existing stuff is totally broken, so I have no objections to you checking this in. Thanks!

[EricWF]

In D25154#564980, @STL_MSFT wrote:

Seems plausible to me. I haven't tested this against MSVC yet, but at most I expect to have minor issues with space consumption (as we allocate helper objects and sentinel nodes, so any exactly-sized buffers may run out of room). In any event the existing stuff is totally broken, so I have no objections to you checking this in. Thanks!

Please let me know if any of your tests remain broken, so I can fix this further.

[STL_MSFT]

msvc_warnings.txt5 KBDownload

• The attached patch on top of your patch fixes two simple MSVC warnings - unreferenced formal parameter and class/struct mismatch.

• Three tests are emitting stack consumption warnings (since MSVC /analyze tries to understand what's going on in the stack):

test\std\containers\sequences\deque\deque.cons\iter_iter.pass.cpp
iter_iter.pass.cpp(50) : warning C6262: Function uses '32868' bytes of stack: exceeds /analyze:stacksize '16384'. Consider moving some data to heap.

test\std\containers\sequences\deque\deque.cons\size.pass.cpp
size.pass.cpp(85) : warning C6262: Function uses '800032' bytes of stack: exceeds /analyze:stacksize '16384'. Consider moving some data to heap.

test\std\containers\sequences\deque\deque.cons\size_value_alloc.pass.cpp
size_value_alloc.pass.cpp(34) : warning C6262: Function uses '80044' bytes of stack: exceeds /analyze:stacksize '16384'. Consider moving some data to heap.

The 800KB consumption seems especially egregious. Changing these tests to dynamically allocate these huge objects will silence the warning.

• Finally, the following tests are asserting:

test\std\containers\sequences\vector\vector.capacity\reserve.pass.cpp
test\std\containers\sequences\vector\vector.capacity\resize_size.pass.cpp
test\std\containers\sequences\vector\vector.capacity\resize_size_value.pass.cpp
test\std\containers\sequences\vector\vector.cons\construct_iter_iter_alloc.pass.cpp
test\std\containers\sequences\vector\vector.cons\construct_size_value_alloc.pass.cpp
test\std\containers\sequences\vector\vector.modifiers\push_back.pass.cpp
test\std\containers\sequences\vector\vector.modifiers\push_back_rvalue.pass.cpp

This is because of the exact-space-consumption issue I feared/predicted - you're constructing stack_allocators with a small fixed amount of space, but our debug object occupies space, and that makes the allocator run out of memory.

A possible fix would be to increase the amount of space (two pointers should be sufficient).

[EricWF]

Rewrite the patch entirely. Instead of using an actual "stack buffer" I've transformed stack_allocator into limited_allocator<T, N> which allows at most N elements to be allocated from it. This resolves the issues about stack usage but it doesn't help with the MSVC debug extra allocations.

test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 
 // explicit priority_queue(const Compare& comp);
 
 #include <queue>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {
-    std::priority_queue<int, std::vector<int, stack_allocator<int, 10> > > q((std::less<int>()));
+    std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q((std::less<int>()));
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
 }

test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 
 // priority_queue();
 
 #include <queue>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {
-    std::priority_queue<int, std::vector<int, stack_allocator<int, 10> > > q;
+    std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
 }

test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 
 // queue();
 
 #include <queue>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {
-    std::queue<int, std::vector<int, stack_allocator<int, 10> > > q;
+    std::queue<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.front() == 1);
     assert(q.back() == 2);
 }

test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp

 // <stack>
 
 // stack();
 
 #include <stack>
 #include <vector>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 
 int main()
 {
-    std::stack<int, std::vector<int, stack_allocator<int, 10> > > q;
+    std::stack<int, std::vector<int, limited_allocator<int, 10> > > q;
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
 }

test/std/containers/sequences/deque/deque.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque()
 
 #include <deque>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "../../../NotConstructible.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test()
 {
     std::deque<T, Allocator> d;
     assert(d.size() == 0);
 #if TEST_STD_VER >= 11
     std::deque<T, Allocator> d1 = {};
     assert(d1.size() == 0);
 #endif
 }
 
 int main()
 {
     test<int, std::allocator<int> >();
-    test<NotConstructible, stack_allocator<NotConstructible, 1> >();
+    test<NotConstructible, limited_allocator<NotConstructible, 1> >();
 #if TEST_STD_VER >= 11
     test<int, min_allocator<int> >();
     test<NotConstructible, min_allocator<NotConstructible> >();
 #endif
 }

test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class InputIterator> deque(InputIterator f, InputIterator l);
 
 #include <deque>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class InputIterator>
 void
 test(InputIterator f, InputIterator l)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;

 int main()
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);
     test(input_iterator<const int*>(ab), input_iterator<const int*>(an));
     test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an));
     test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an));
     test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an));
-    test<stack_allocator<int, 4096> >(ab, an);
+    test<limited_allocator<int, 4096> >(ab, an);
 #if TEST_STD_VER >= 11
     test<min_allocator<int> >(ab, an);
 #endif
 }

test/std/containers/sequences/deque/deque.cons/size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // explicit deque(size_type n);
 
 #include <deque>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test2(unsigned n)
 {
 #if _LIBCPP_STD_VER > 11
int main()
     test<DefaultOnly, std::allocator<DefaultOnly> >(1025);
     test<DefaultOnly, std::allocator<DefaultOnly> >(2047);
     test<DefaultOnly, std::allocator<DefaultOnly> >(2048);
     test<DefaultOnly, std::allocator<DefaultOnly> >(2049);
     test<DefaultOnly, std::allocator<DefaultOnly> >(4095);
     test<DefaultOnly, std::allocator<DefaultOnly> >(4096);
     test<DefaultOnly, std::allocator<DefaultOnly> >(4097);
 
-    test1<DefaultOnly, stack_allocator<DefaultOnly, 4096> >(4095);
+    test1<DefaultOnly, limited_allocator<DefaultOnly, 4096> >(4095);
 
 #if TEST_STD_VER >= 11
     test<DefaultOnly, min_allocator<DefaultOnly> >(4095);
 #endif
 
 #if _LIBCPP_STD_VER > 11
     test3<DefaultOnly, std::allocator<DefaultOnly>> (1023);
     test3<int, std::allocator<int>>(1);
     test3<int, min_allocator<int>> (3);
 #endif
 
 }

test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(size_type n, const value_type& v);
 
 #include <deque>
 #include <cassert>
 
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test(unsigned n, const T& x)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
int main()
     test<int, std::allocator<int> >(1024, 25);
     test<int, std::allocator<int> >(1025, 0);
     test<int, std::allocator<int> >(2047, 110);
     test<int, std::allocator<int> >(2048, -500);
     test<int, std::allocator<int> >(2049, 654);
     test<int, std::allocator<int> >(4095, 78);
     test<int, std::allocator<int> >(4096, 1165);
     test<int, std::allocator<int> >(4097, 157);
-    test<int, stack_allocator<int, 4096> >(4095, 90);
+    test<int, limited_allocator<int, 4096> >(4095, 90);
 #if TEST_STD_VER >= 11
     test<int, min_allocator<int> >(4095, 90);
 #endif
 }

test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

 //   iterator insert (const_iterator p, InputIterator f, InputIterator l);
 
 #include <deque>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "MoveOnly.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);
     int init = 0;
int main()
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int> >(rng[i], rng[j], rng[k]);
     testNI<std::deque<int> >(1500, 2000, 1000);
 #if TEST_STD_VER >= 11
-    test_move<std::deque<MoveOnly, stack_allocator<MoveOnly, 2000> > >();
+    test_move<std::deque<MoveOnly, limited_allocator<MoveOnly, 2000> > >();
 #endif
     }
 #if TEST_STD_VER >= 11
     {
     int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
     const int N = sizeof(rng)/sizeof(rng[0]);
     for (int i = 0; i < N; ++i)
         for (int j = 0; j < N; ++j)
             for (int k = 0; k < N; ++k)
                 testN<std::deque<int, min_allocator<int>> >(rng[i], rng[j], rng[k]);
     testNI<std::deque<int> >(1500, 2000, 1000);
     test_move<std::deque<MoveOnly, min_allocator<MoveOnly> > >();
     }
 #endif
 }

test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // explicit list(const Alloc& = Alloc());
 
 #include <list>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         std::list<int> l;
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
     {
         std::list<int> l((std::allocator<int>()));
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
     {
-        std::list<int, stack_allocator<int, 4> > l;
+        std::list<int, limited_allocator<int, 4> > l;
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l;
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
     {
         std::list<int, min_allocator<int>> l((min_allocator<int>()));
         assert(l.size() == 0);
         assert(std::distance(l.begin(), l.end()) == 0);
     }
 #endif
 }

test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp

 // <list>
 
 // template <class InputIterator>
 //   list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 
 #include <list>
 #include <cassert>
 #include "test_iterators.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         int a[] = {0, 1, 2, 3};
         std::list<int> l(input_iterator<const int*>(a),
                          input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
int main()
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
         int j = 0;
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
     {
         int a[] = {0, 1, 2, 3};
-        std::list<int, stack_allocator<int, sizeof(a)/sizeof(a[0])> > l(input_iterator<const int*>(a),
+        std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0])> > l(input_iterator<const int*>(a),
                          input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
         int j = 0;
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
 #if TEST_STD_VER >= 11

test/std/containers/sequences/list/list.cons/size_type.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // explicit list(size_type n);
 
 #include <list>
 #include <cassert>
 #include "DefaultOnly.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test3(unsigned n, Allocator const &alloc = Allocator())
 {
 #if _LIBCPP_STD_VER > 11
     typedef std::list<T, Allocator> C;
int main()
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 0);
         ++i;
         assert(*i == 0);
         ++i;
         assert(*i == 0);
     }
     {
-        std::list<int, stack_allocator<int, 3> > l(3);
+        std::list<int, limited_allocator<int, 3> > l(3);
         assert(l.size() == 3);
         assert(std::distance(l.begin(), l.end()) == 3);
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 0);
         ++i;
         assert(*i == 0);
         ++i;
         assert(*i == 0);

test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // list(size_type n, const T& value, const Allocator& = Allocator());
 
 #include <list>
 #include <cassert>
 #include "DefaultOnly.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         std::list<int> l(3, 2);
         assert(l.size() == 3);
         assert(std::distance(l.begin(), l.end()) == 3);
int main()
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 2);
     }
     {
-        std::list<int, stack_allocator<int, 3> > l(3, 2);
+        std::list<int, limited_allocator<int, 3> > l(3, 2);
         assert(l.size() == 3);
         assert(std::distance(l.begin(), l.end()) == 3);
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 2);

test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void reserve(size_type n);
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v;
         v.reserve(10);
         assert(v.capacity() >= 10);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
         std::vector<int> v(100);
         assert(v.capacity() == 100);
         v.reserve(50);
         assert(v.size() == 100);
         assert(v.capacity() == 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
-        std::vector<int, stack_allocator<int, 250> > v(100);
+        std::vector<int, limited_allocator<int, 250> > v(100);
         assert(v.capacity() == 100);
         v.reserve(50);
         assert(v.size() == 100);
         assert(v.capacity() == 100);
         v.reserve(150);
         assert(v.size() == 100);
         assert(v.capacity() == 150);
         assert(is_contiguous_container_asan_correct(v));

test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void resize(size_type sz);
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::vector<MoveOnly> v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
-        std::vector<MoveOnly, stack_allocator<MoveOnly, 300> > v(100);
+        std::vector<MoveOnly, limited_allocator<MoveOnly, 300> > v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::vector<int> v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
-        std::vector<int, stack_allocator<int, 300> > v(100);
+        std::vector<int, limited_allocator<int, 300> > v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));

test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void resize(size_type sz, const value_type& x);
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v(100);
         v.resize(50, 1);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(v == std::vector<int>(50));
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
         for (unsigned i = 0; i < 50; ++i)
             assert(v[i] == 0);
         for (unsigned i = 50; i < 200; ++i)
             assert(v[i] == 1);
     }
     {
-        std::vector<int, stack_allocator<int, 300> > v(100);
+        std::vector<int, limited_allocator<int, 300> > v(100);
         v.resize(50, 1);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }

test/std/containers/sequences/vector/vector.capacity/shrink_to_fit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void shrink_to_fit();
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
-        std::vector<int, stack_allocator<int, 401> > v(100);
+        std::vector<int, limited_allocator<int, 401> > v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         assert(v.capacity() == 101);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     {
-        std::vector<int, stack_allocator<int, 400> > v(100);
+        std::vector<int, limited_allocator<int, 400> > v(100);
         v.push_back(1);
         assert(is_contiguous_container_asan_correct(v));
         v.shrink_to_fit();
         LIBCPP_ASSERT(v.capacity() == 200); // assumes libc++'s 2x growth factor
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
     }
 #endif

test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp

 // vector(const Alloc&);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../../../NotConstructible.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
 void
 test0()
 {
 #if TEST_STD_VER > 14
int main()
     {
     test0<std::vector<int> >();
     test0<std::vector<NotConstructible> >();
     test1<std::vector<int, test_allocator<int> > >(test_allocator<int>(3));
     test1<std::vector<NotConstructible, test_allocator<NotConstructible> > >
         (test_allocator<NotConstructible>(5));
     }
     {
-        std::vector<int, stack_allocator<int, 10> > v;
+        std::vector<int, limited_allocator<int, 10> > v;
         assert(v.empty());
     }
 #if TEST_STD_VER >= 11
     {
     test0<std::vector<int, min_allocator<int>> >();
     test0<std::vector<NotConstructible, min_allocator<NotConstructible>> >();
     test1<std::vector<int, min_allocator<int> > >(min_allocator<int>{});
     test1<std::vector<NotConstructible, min_allocator<NotConstructible> > >

test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

 
 // template <class InputIter> vector(InputIter first, InputIter last);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C, class Iterator>
 void
 test(Iterator first, Iterator last)
 {
     C c(first, last);
int main()
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
     int* an = a + sizeof(a)/sizeof(a[0]);
     test<std::vector<int> >(input_iterator<const int*>(a), input_iterator<const int*>(an));
     test<std::vector<int> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
     test<std::vector<int> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
     test<std::vector<int> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
     test<std::vector<int> >(a, an);
 
-    test<std::vector<int, stack_allocator<int, 63> > >(input_iterator<const int*>(a), input_iterator<const int*>(an));
-    test<std::vector<int, stack_allocator<int, 18> > >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
-    test<std::vector<int, stack_allocator<int, 18> > >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
-    test<std::vector<int, stack_allocator<int, 18> > >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
-    test<std::vector<int, stack_allocator<int, 18> > >(a, an);
+    test<std::vector<int, limited_allocator<int, 63> > >(input_iterator<const int*>(a), input_iterator<const int*>(an));
+    test<std::vector<int, limited_allocator<int, 18> > >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
+    test<std::vector<int, limited_allocator<int, 18> > >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
+    test<std::vector<int, limited_allocator<int, 18> > >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
+    test<std::vector<int, limited_allocator<int, 18> > >(a, an);
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(input_iterator<const int*>(a), input_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
     test<std::vector<int> >(a, an);
 #endif
 }

test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

 // template <class InputIter> vector(InputIter first, InputIter last,
 //                                   const allocator_type& a);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C, class Iterator, class A>
 void
 test(Iterator first, Iterator last, const A& a)
 {
     C c(first, last, a);

test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp

 // <vector>
 
 // vector(size_type n, const value_type& x);
 
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
 void
 test(typename C::size_type n, const typename C::value_type& x)
 {
     C c(n, x);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == n);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i)
         assert(*i == x);
 }
 
 int main()
 {
     test<std::vector<int> >(50, 3);
-    test<std::vector<int, stack_allocator<int, 50> > >(50, 5);
+    test<std::vector<int, limited_allocator<int, 50> > >(50, 5);
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(50, 3);
 #endif
 }

test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp

 // template <class... Args> iterator emplace(const_iterator pos, Args&&... args);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 class A
 {
     int i_;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.front().getd() == 3.5);
         assert(c[1].geti() == 4);
         assert(c[1].getd() == 6.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
         assert(is_contiguous_container_asan_correct(c));
     }
     {
-        std::vector<A, stack_allocator<A, 7> > c;
-        std::vector<A, stack_allocator<A, 7> >::iterator i = c.emplace(c.cbegin(), 2, 3.5);
+        std::vector<A, limited_allocator<A, 7> > c;
+        std::vector<A, limited_allocator<A, 7> >::iterator i = c.emplace(c.cbegin(), 2, 3.5);
         assert(i == c.begin());
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
         assert(is_contiguous_container_asan_correct(c));
         i = c.emplace(c.cend(), 3, 4.5);
         assert(i == c.end()-1);
         assert(c.size() == 2);

test/std/containers/sequences/vector/vector.modifiers/emplace_back.pass.cpp

 // UNSUPPORTED: c++98, c++03
 
 // <vector>
 
 // template <class... Args> reference emplace_back(Args&&... args);
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "asan_testing.h"
 
 class A
 {
     int i_;
     double d_;
int main()
         assert(&r2 == &c.back());
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
         assert(is_contiguous_container_asan_correct(c));
     }
     {
-        std::vector<A, stack_allocator<A, 4> > c;
+        std::vector<A, limited_allocator<A, 4> > c;
         A& r1 = c.emplace_back(2, 3.5);
         assert(c.size() == 1);
         assert(&r1 == &c.back());
         assert(c.front().geti() == 2);
         assert(c.front().getd() == 3.5);
         assert(is_contiguous_container_asan_correct(c));
         A& r2 = c.emplace_back(3, 4.5);
         assert(c.size() == 2);

test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

 //   iterator insert(const_iterator position, Iter first, Iter last);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v(100);
int main()
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int, stack_allocator<int, 308> > v(100);
+        std::vector<int, limited_allocator<int, 308> > v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int, stack_allocator<int, 300> > v(100);
+        std::vector<int, limited_allocator<int, 300> > v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;

test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp

 // iterator insert(const_iterator position, value_type&& x);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::vector<MoveOnly> v(100);
         std::vector<MoveOnly>::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == MoveOnly());
         assert(v[j] == MoveOnly(3));
         for (++j; j < 101; ++j)
             assert(v[j] == MoveOnly());
     }
     {
-        std::vector<MoveOnly, stack_allocator<MoveOnly, 300> > v(100);
-        std::vector<MoveOnly, stack_allocator<MoveOnly, 300> >::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
+        std::vector<MoveOnly, limited_allocator<MoveOnly, 300> > v(100);
+        std::vector<MoveOnly, limited_allocator<MoveOnly, 300> >::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == MoveOnly());
         assert(v[j] == MoveOnly(3));
         for (++j; j < 101; ++j)

test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp

 // iterator insert(const_iterator position, size_type n, const value_type& x);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v(100);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
int main()
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int, stack_allocator<int, 300> > v(100);
-        std::vector<int, stack_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 5, 1);
+        std::vector<int, limited_allocator<int, 300> > v(100);
+        std::vector<int, limited_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);

test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp

 // iterator insert(const_iterator position, const value_type& x);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v(100);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int, stack_allocator<int, 300> > v(100);
-        std::vector<int, stack_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 1);
+        std::vector<int, limited_allocator<int, 300> > v(100);
+        std::vector<int, limited_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < 101; ++j)

test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp

 // void pop_back();
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 
 #if _LIBCPP_DEBUG >= 1
 #include <cstdlib>
 #include <exception>
 
 #endif
 

test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void push_back(const value_type& x);
 
 #include <vector>
 #include <cassert>
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> c;
         c.push_back(0);
int main()
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
     }
     {
-        std::vector<int, stack_allocator<int, 15> > c;
+        std::vector<int, limited_allocator<int, 15> > c;
         c.push_back(0);
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));

test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void push_back(value_type&& x);
 
 #include <vector>
 #include <cassert>
 #include "MoveOnly.h"
-#include "../../../stack_allocator.h"
+#include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::vector<MoveOnly> c;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
     {
-        std::vector<MoveOnly, stack_allocator<MoveOnly, 15> > c;
+        std::vector<MoveOnly, limited_allocator<MoveOnly, 15> > c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));

test/std/containers/stack_allocator.h

-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef STACK_ALLOCATOR_H
-#define STACK_ALLOCATOR_H
-
-#include <cstddef>
-#include <new>
-
-template <class T, std::size_t N>
-class stack_allocator
-{
-    char buf_[sizeof(T)*N];
-    char* ptr_;
-public:
-    typedef T                 value_type;
-    typedef value_type*       pointer;
-    typedef const value_type* const_pointer;
-    typedef value_type&       reference;
-    typedef const value_type& const_reference;
-    typedef std::size_t       size_type;
-    typedef std::ptrdiff_t    difference_type;
-
-    template <class U> struct rebind {typedef stack_allocator<U, N> other;};
-
-    stack_allocator() : ptr_(buf_) {}
-
-private:
-    stack_allocator(const stack_allocator&);// = delete;
-    stack_allocator& operator=(const stack_allocator&);// = delete;
-
-public:
-    pointer allocate(size_type n, const void* = 0)
-    {
-        if (n > N - (ptr_ - buf_) / sizeof(value_type)) {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-            throw std::bad_alloc();
-#else
-            std::terminate();
-#endif
-        }
-        pointer r = (T*)ptr_;
-        ptr_ += n * sizeof(T);
-        return r;
-    }
-    void deallocate(pointer p, size_type n)
-    {
-        if ((char*)(p + n) == ptr_)
-            ptr_ = (char*)p;
-    }
-
-    size_type max_size() const {return N;}
-};
-
-template <class T, std::size_t N>
-inline
-void
-swap(stack_allocator<T, N>& x, stack_allocator<T, N>& y) {}
-
-#endif  // STACK_ALLOCATOR_H

test/support/test_allocator.h

 { return true; }
 
 template<typename T, typename U>
 bool
 operator!=(const TaggingAllocator<T>&, const TaggingAllocator<U>&)
 { return false; }
 #endif
 
+template <std::size_t MaxAllocs>
+struct limited_alloc_handle {
+  std::size_t outstanding_;
+  void* last_alloc_;
+
+  limited_alloc_handle() : outstanding_(0), last_alloc_(nullptr) {}
+
+  template <class T>
+  T *allocate(std::size_t N) {
+    if (N + outstanding_ > MaxAllocs)
+      TEST_THROW(std::bad_alloc());
+    last_alloc_ = ::operator new(N*sizeof(T));
+    outstanding_ += N;
+    return static_cast<T*>(last_alloc_);
+  }
+
+  void deallocate(void* ptr, std::size_t N) {
+    if (ptr == last_alloc_) {
+      last_alloc_ = nullptr;
+      assert(outstanding_ >= N);
+      outstanding_ -= N;
+    }
+    ::operator delete(ptr);
+  }
+};
+
+template <class T, std::size_t N>
+class limited_allocator
+{
+    typedef limited_alloc_handle<N> BuffT;
+    std::shared_ptr<BuffT> handle_;
+public:
+    typedef T                 value_type;
+    typedef value_type*       pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type&       reference;
+    typedef const value_type& const_reference;
+    typedef std::size_t       size_type;
+    typedef std::ptrdiff_t    difference_type;
+
+    template <class U> struct rebind { typedef limited_allocator<U, N> other; };
+
+    limited_allocator() : handle_(new BuffT) {}
+
+    limited_allocator(limited_allocator const& other) : handle_(other.handle_) {}
+
+    template <class U>
+    explicit limited_allocator(limited_allocator<U, N> const& other)
+        : handle_(other.handle_) {}
+
+private:
+    limited_allocator& operator=(const limited_allocator&);// = delete;
+
+public:
+    pointer allocate(size_type n) { return handle_->template allocate<T>(n); }
+    void deallocate(pointer p, size_type n) { handle_->deallocate(p, n); }
+    size_type max_size() const {return N;}
+
+    BuffT* getHandle() const { return handle_.get(); }
+};
+
+template <class T, class U, std::size_t N>
+inline bool operator==(limited_allocator<T, N> const& LHS,
+                       limited_allocator<U, N> const& RHS) {
+  return LHS.getHandle() == RHS.getHandle();
+}
+
+template <class T, class U, std::size_t N>
+inline bool operator!=(limited_allocator<T, N> const& LHS,
+                       limited_allocator<U, N> const& RHS) {
+  return !(LHS == RHS);
+}
+
 
 #endif  // TEST_ALLOCATOR_H