[libcxx] Attempt to fix undefined behavior in list, forward_list and __tree.

[EricWF]

Summary

I'm not 100% confident in this patch yet but because of the time crunch with the 3.6 release I'm posting it early.

The patch works by using static_cast on fancy class-like pointers and reinterpret_cast on raw pointers. It also changes it so that when the base node class is needed at a call site then it gets the base pointer directly instead of the derived pointer.

I'll do more work on this and actually convince myself of its correctness.

[rsmith]

It seems to me that the right thing to do is to fix __tree and __tree_iterator to use the appropriate pointer type for all stored pointers. That is, __tree_node_base::__right_, __tree_iterator::__ptr_, __tree_const_iterator::__ptr_, and __tree::__begin_node_ should be pointers to __tree_end_node, because they might point to a __tree_end_node that is not a __tree_node_base.

As-is, the code *still* has undefined behavior in the case where the element type has a higher alignment requirement than that of a pointer, because you will potentially use a node_pointer to point to an element that is not suitably aligned to be represented as such a pointer value. This problem doesn't arise if you only use a pointer-to-T type to point at a T object.

include/memory

5452–5458

It seems strange to use static_cast here and reinterpret_cast below. Even assuming the reinterpret_cast approach works, don't we still have the same problem if the user uses a fancy pointer type?

[awi]

Strange, I can't see much difference in include/list. Only list::end() (with and without const) and __list_node_base::__self() have been changed and use the new _FancyPointerCaster<>, but all this does is replace the old static_casts with reinterpret_casts, if the allocater defines pointer to be a built-in pointer. If it is a fancy pointer, your patch doesn't change anything at all! How is that supposed to fix the bug?
I've just checked your patch with my two example files. As I expected, main.cpp works, with or without your patch, and main2.cpp doesn't work, with or without your patch. I'm sorry.

By the way: what is the purpose of _FancyPointerCaster<>? I don't quite understand what you need it for, because all it does is choose whether to use a static_cast or a reinterpret_cast.

The class __tree seems more complicated and uses three instead of two node classes: __tree_node and __tree_node_base work like their counterparts in list, and then there is __tree_end_node for the end node that is the parent of the tree's root node and the target of the end iterator. As far as I understand it, a __tree_node_base is never created: all regular nodes are __tree_nodes and the end node is a __tree_end_node. Therefore I don't expect any aliasing problems between __tree_node and __tree_node_base, only between __tree_node and __tree_end_node.
Your patch introduces a new function __tree::__end_node_pointer() that returns the end node as a pointer of that base class __tree_end_node, and it calls that function whenever it needs to access the end node. This looks good to me and should solve some strict aliasing problems.
Alas, not all of them! The end iterator is a __tree_iterator and thus points to the end node with a __tree_node_pointer. The operator--() casts these to __node_base_pointer first, but not to __end_node_ptr, so the very moment it accesses the __left_ field, it breaks the strict aliasing rule again (operator++() works the same way, but this is fine, because it would be an error in the application to call operator++() on the end node). The same is true for __tree_node_base::__parent_, whose type points to a __tree_node_base, although the parent of the root node is the end node. Note, that it's safe for __left_ and __right_ to point to __tree_node_base, because due to the structure of the tree they can never point to the end node: only __parent_ and the end iterator can, in addition to all functions that call __end_node() or __end_node_pointer().
Unfortunately, I cannot present you a counterexample this time: that bug seems to be much harder to trigger in __tree than in std::list.

Finally, I've had a look into std::forward_list. Similar to __tree, you have replaced some calls to __before_begin() with calls to a new function __before_begin_pointer(), which returns the __before_begin node as a __begin_node_pointer instead of __node_pointer.
In my opinion, this is more appropriate and may solve some strict aliasing problems, but not all of them. The function forward_list::before_begin() still returns a __forward_list_iterator<__node_pointer> that contains a pointer to a __forward_list_node, although it actually points to a __forward_begin_node instead. Dereferencing that iterator violates strict aliasing, as can be seen from the fourth attachment to the bug entry: It fails, with or without your patch.

[EricWF]

Abandoning. All issues have been addressed by other commits.

include/memory

5452–5458

Yeah, I couldn't find a better way to convert fancy pointers. Perhaps we need to cast to a void pointer as a go between.

include/__tree

     _LIBCPP_INLINE_VISIBILITY
     __node_pointer __end_node() _NOEXCEPT
     {
-        return static_cast<__node_pointer>
-               (
-                   pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
-               );
+        typedef _FancyPointerCaster<__end_node_ptr, __node_pointer> _Caster;
+        return _Caster::__from_element(__pair1_.first());
     }
     _LIBCPP_INLINE_VISIBILITY
     __node_const_pointer __end_node() const _NOEXCEPT
     {
-        return static_cast<__node_const_pointer>
-               (
-                   pointer_traits<__end_node_const_ptr>::pointer_to(const_cast<__end_node_t&>(__pair1_.first()))
-               );
+        typedef _FancyPointerCaster<__end_node_const_ptr, __node_const_pointer> _Caster;
+        return _Caster::__from_element(const_cast<__end_node_t&>(__pair1_.first()));
+    }
+    _LIBCPP_INLINE_VISIBILITY
+    __end_node_ptr __end_node_pointer() _NOEXCEPT
+    {
+        return pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first());
+    }
+    _LIBCPP_INLINE_VISIBILITY
+    __end_node_const_ptr __end_node_pointer() const _NOEXCEPT
+    {
+        return pointer_traits<__end_node_const_ptr>::pointer_to(const_cast<__end_node_t&>(__pair1_.first()));
     }
     _LIBCPP_INLINE_VISIBILITY
           __node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}

 public:
     _LIBCPP_INLINE_VISIBILITY
     __node_pointer __root() _NOEXCEPT
-        {return static_cast<__node_pointer>      (__end_node()->__left_);}
+        {return static_cast<__node_pointer>      (__end_node_pointer()->__left_);}
     _LIBCPP_INLINE_VISIBILITY
     __node_const_pointer __root() const _NOEXCEPT
-        {return static_cast<__node_const_pointer>(__end_node()->__left_);}
+        {return static_cast<__node_const_pointer>(__end_node_pointer()->__left_);}
 
     typedef __tree_iterator<value_type, __node_pointer, difference_type>             iterator;
     typedef __tree_const_iterator<value_type, __node_pointer, difference_type> const_iterator;

 {
     __node_pointer __cache = __begin_node();
     __begin_node() = __end_node();
-    __end_node()->__left_->__parent_ = nullptr;
-    __end_node()->__left_ = nullptr;
+    __end_node_pointer()->__left_->__parent_ = nullptr;
+    __end_node_pointer()->__left_ = nullptr;
     size() = 0;
     // __cache->__left_ == nullptr
     if (__cache->__right_ != nullptr)

         __begin_node() = __end_node();
     else
     {
-        __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+        __end_node_pointer()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
-        __t.__end_node()->__left_ = nullptr;
+        __t.__end_node_pointer()->__left_ = nullptr;
         __t.size() = 0;
     }
 }

         else
         {
             __begin_node() = __t.__begin_node();
-            __end_node()->__left_ = __t.__end_node()->__left_;
-            __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+            __end_node_pointer()->__left_ = __t.__end_node_pointer()->__left_;
+            __end_node_pointer()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
             size() = __t.size();
             __t.__begin_node() = __t.__end_node();
-            __t.__end_node()->__left_ = nullptr;
+            __t.__end_node_pointer()->__left_ = nullptr;
             __t.size() = 0;
         }
     }

     _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
                is_nothrow_move_assignable<__node_allocator>::value)
 {
-    destroy(static_cast<__node_pointer>(__end_node()->__left_));
+    destroy(static_cast<__node_pointer>(__end_node_pointer()->__left_));
     __begin_node_ = __t.__begin_node_;
     __pair1_.first() = __t.__pair1_.first();
     __move_assign_alloc(__t);

         __begin_node() = __end_node();
     else
     {
-        __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+        __end_node_pointer()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
         __t.__begin_node() = __t.__end_node();
-        __t.__end_node()->__left_ = nullptr;
+        __t.__end_node_pointer()->__left_ = nullptr;
         __t.size() = 0;
     }
 }

     if (size() == 0)
         __begin_node() = __end_node();
     else
-        __end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
+        __end_node_pointer()->__left_->__parent_ = static_cast<__node_base_pointer>(__end_node());
     if (__t.size() == 0)
         __t.__begin_node() = __t.__end_node();
     else
-        __t.__end_node()->__left_->__parent_ = static_cast<__node_base_pointer>(__t.__end_node());
+        __t.__end_node_pointer()->__left_->__parent_ = static_cast<__node_base_pointer>(__t.__end_node());
 }
 
 template <class _Tp, class _Compare, class _Allocator>

     destroy(__root());
     size() = 0;
     __begin_node() = __end_node();
-    __end_node()->__left_ = nullptr;
+    __end_node_pointer()->__left_ = nullptr;
 }
 
 // Find lower_bound place to insert

     __child = __new_node;
     if (__begin_node()->__left_ != nullptr)
         __begin_node() = static_cast<__node_pointer>(__begin_node()->__left_);
-    __tree_balance_after_insert(__end_node()->__left_, __child);
+    __tree_balance_after_insert(__end_node_pointer()->__left_, __child);
     ++size();
 }
 

         __begin_node() = __r.__ptr_;
     --size();
     __node_allocator& __na = __node_alloc();
-    __tree_remove(__end_node()->__left_,
+    __tree_remove(__end_node_pointer()->__left_,
                   static_cast<__node_base_pointer>(__np));
     __node_traits::destroy(__na, const_cast<value_type*>(_VSTD::addressof(*__p)));
     __node_traits::deallocate(__na, __np, 1);

             __begin_node() = static_cast<__node_pointer>(__np->__parent_);
     }
     --size();
-    __tree_remove(__end_node()->__left_,
+    __tree_remove(__end_node_pointer()->__left_,
                   static_cast<__node_base_pointer>(__np));
     return __node_holder(__np, _Dp(__node_alloc()));
 }

include/forward_list

 
     _LIBCPP_INLINE_VISIBILITY
     __node_pointer        __before_begin() _NOEXCEPT
-        {return static_cast<__node_pointer>(pointer_traits<__begin_node_pointer>::
-                                        pointer_to(__before_begin_.first()));}
+    {
+      typedef _FancyPointerCaster<__begin_node_pointer, __node_pointer> _Caster;
+      return _Caster::__from_element(__before_begin_.first());
+    }
+
     _LIBCPP_INLINE_VISIBILITY
     __node_const_pointer  __before_begin() const _NOEXCEPT
-        {return static_cast<__node_const_pointer>(pointer_traits<__begin_node_pointer>::
-                                        pointer_to(const_cast<__begin_node&>(__before_begin_.first())));}
+    {
+      typedef _FancyPointerCaster<__begin_node_pointer, __node_const_pointer> _Caster;
+      return _Caster::__from_element(const_cast<__begin_node&>(__before_begin_.first()));
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __begin_node_pointer __before_begin_pointer() _NOEXCEPT
+    {
+      return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_.first());
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __begin_node_pointer __before_begin_pointer() const _NOEXCEPT
+    {
+      return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_.first()));
+    }
 
     _LIBCPP_INLINE_VISIBILITY
           __node_allocator& __alloc() _NOEXCEPT

         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
     : __before_begin_(_VSTD::move(__x.__before_begin_))
 {
-    __x.__before_begin()->__next_ = nullptr;
+    __x.__before_begin_pointer()->__next_ = nullptr;
 }
 
 template <class _Tp, class _Alloc>

 {
     if (__alloc() == __x.__alloc())
     {
-        __before_begin()->__next_ = __x.__before_begin()->__next_;
-        __x.__before_begin()->__next_ = nullptr;
+        __before_begin_pointer()->__next_ = __x.__before_begin_pointer()->__next_;
+        __x.__before_begin_pointer()->__next_ = nullptr;
     }
 }
 

 {
     __swap_alloc(__alloc(), __x.__alloc());
     using _VSTD::swap;
-    swap(__before_begin()->__next_, __x.__before_begin()->__next_);
+    swap(__before_begin_pointer()->__next_, __x.__before_begin_pointer()->__next_);
 }
 
 template <class _Tp, class _Alloc>

 __forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT
 {
     __node_allocator& __a = __alloc();
-    for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
+    for (__node_pointer __p = __before_begin_pointer()->__next_; __p != nullptr;)
     {
         __node_pointer __next = __p->__next_;
         __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
         __node_traits::deallocate(__a, __p, 1);
         __p = __next;
     }
-    __before_begin()->__next_ = nullptr;
+    __before_begin_pointer()->__next_ = nullptr;
 }
 
 template <class _Tp, class _Alloc = allocator<_Tp> >

     : private __forward_list_base<_Tp, _Alloc>
 {
     typedef __forward_list_base<_Tp, _Alloc> base;
-    typedef typename base::__node_allocator  __node_allocator;
-    typedef typename base::__node            __node;
-    typedef typename base::__node_traits     __node_traits;
-    typedef typename base::__node_pointer    __node_pointer;
+    typedef typename base::__node_allocator     __node_allocator;
+    typedef typename base::__node               __node;
+    typedef typename base::__node_traits        __node_traits;
+    typedef typename base::__node_pointer       __node_pointer;
+    typedef typename base::__begin_node_pointer __begin_node_pointer;
 
 public:
     typedef _Tp    value_type;

 
     _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT
-        {return       iterator(base::__before_begin()->__next_);}
+        {return       iterator(base::__before_begin_pointer()->__next_);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin()->__next_);}
+        {return const_iterator(base::__before_begin_pointer()->__next_);}
     _LIBCPP_INLINE_VISIBILITY
     iterator       end() _NOEXCEPT
         {return       iterator(nullptr);}

 
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cbegin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin()->__next_);}
+        {return const_iterator(base::__before_begin_pointer()->__next_);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend() const _NOEXCEPT
         {return const_iterator(nullptr);}

 
     _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
-        {return base::__before_begin()->__next_ == nullptr;}
+        {return base::__before_begin_pointer()->__next_ == nullptr;}
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT
         {return numeric_limits<size_type>::max();}
 
     _LIBCPP_INLINE_VISIBILITY
-    reference       front()       {return base::__before_begin()->__next_->__value_;}
+    reference       front()       {return base::__before_begin_pointer()->__next_->__value_;}
     _LIBCPP_INLINE_VISIBILITY
-    const_reference front() const {return base::__before_begin()->__next_->__value_;}
+    const_reference front() const {return base::__before_begin_pointer()->__next_->__value_;}
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_VARIADICS

 {
     clear();
     base::__move_assign_alloc(__x);
-    base::__before_begin()->__next_ = __x.__before_begin()->__next_;
-    __x.__before_begin()->__next_ = nullptr;
+    base::__before_begin_pointer()->__next_ = __x.__before_begin_pointer()->__next_;
+    __x.__before_begin_pointer()->__next_ = nullptr;
 }
 
 template <class _Tp, class _Alloc>

     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
     __node_traits::construct(__a, _VSTD::addressof(__h->__value_),
                                   _VSTD::forward<_Args>(__args)...);
-    __h->__next_ = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __h.release();
+    __h->__next_ = base::__before_begin_pointer()->__next_;
+    base::__before_begin_pointer()->__next_ = __h.release();
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS

     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
     __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
-    __h->__next_ = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __h.release();
+    __h->__next_ = base::__before_begin_pointer()->__next_;
+    base::__before_begin_pointer()->__next_ = __h.release();
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

     typedef __allocator_destructor<__node_allocator> _Dp;
     unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
     __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
-    __h->__next_ = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __h.release();
+    __h->__next_ = base::__before_begin_pointer()->__next_;
+    base::__before_begin_pointer()->__next_ = __h.release();
 }
 
 template <class _Tp, class _Alloc>

 forward_list<_Tp, _Alloc>::pop_front()
 {
     __node_allocator& __a = base::__alloc();
-    __node_pointer __p = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __p->__next_;
+    __node_pointer __p = base::__before_begin_pointer()->__next_;
+    base::__before_begin_pointer()->__next_ = __p->__next_;
     __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
     __node_traits::deallocate(__a, __p, 1);
 }

 forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
                                         _InputIterator __f, _InputIterator __l)
 {
+    typedef _FancyPointerCaster<__node_pointer, __begin_node_pointer> _Caster;
     __node_pointer __r = __p.__ptr_;
     if (__f != __l)
     {

             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __last->__next_ = __r->__next_;
-        __r->__next_ = __first;
+        __last->__next_ = _Caster::__from_pointer(__r)->__next_;
+        _Caster::__from_pointer(__r)->__next_ = __first;
         __r = __last;
     }
     return iterator(__r);

                 ++__lm1;
             __lm1.__ptr_->__next_ = __p.__ptr_->__next_;
         }
-        __p.__ptr_->__next_ = __x.__before_begin()->__next_;
-        __x.__before_begin()->__next_ = nullptr;
+        __p.__ptr_->__next_ = __x.__before_begin_pointer()->__next_;
+        __x.__before_begin_pointer()->__next_ = nullptr;
     }
 }
 

 {
     if (this != &__x)
     {
-        base::__before_begin()->__next_ = __merge(base::__before_begin()->__next_,
-                                                    __x.__before_begin()->__next_,
+        base::__before_begin_pointer()->__next_ = __merge(base::__before_begin_pointer()->__next_,
+                                                    __x.__before_begin_pointer()->__next_,
                                                     __comp);
-        __x.__before_begin()->__next_ = nullptr;
+        __x.__before_begin_pointer()->__next_ = nullptr;
     }
 }
 

 void
 forward_list<_Tp, _Alloc>::sort(_Compare __comp)
 {
-    base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_,
+    base::__before_begin_pointer()->__next_ = __sort(base::__before_begin_pointer()->__next_,
                                        _VSTD::distance(begin(), end()), __comp);
 }
 

 void
 forward_list<_Tp, _Alloc>::reverse() _NOEXCEPT
 {
-    __node_pointer __p = base::__before_begin()->__next_;
+    __node_pointer __p = base::__before_begin_pointer()->__next_;
     if (__p != nullptr)
     {
         __node_pointer __f = __p->__next_;

             __p = __f;
             __f = __t;
         }
-        base::__before_begin()->__next_ = __p;
+        base::__before_begin_pointer()->__next_ = __p;
     }
 }
 

include/list

     _LIBCPP_INLINE_VISIBILITY
     pointer __self()
     {
-        return static_cast<pointer>(pointer_traits<__base_pointer>::pointer_to(*this));
+      typedef _FancyPointerCaster<__base_pointer, pointer> _Caster;
+      return _Caster::__from_element(*this);
     }
 };
 

     _LIBCPP_INLINE_VISIBILITY
     iterator end() _NOEXCEPT
     {
+        typedef _FancyPointerCaster<__node_base_pointer, __node_pointer> _Caster;
 #if _LIBCPP_DEBUG_LEVEL >= 2
-        return iterator(static_cast<__node_pointer>(
-                pointer_traits<__node_base_pointer>::pointer_to(__end_)), this);
+        return iterator(_Caster::__from_element(__end_), this);
 #else
-        return iterator(static_cast<__node_pointer>(
-                      pointer_traits<__node_base_pointer>::pointer_to(__end_)));
+        return iterator(_Caster::__from_element(__end_));
 #endif
     }
     _LIBCPP_INLINE_VISIBILITY
     const_iterator end() const _NOEXCEPT
     {
+        typedef _FancyPointerCaster<__node_base_pointer, __node_const_pointer> _Caster;
 #if _LIBCPP_DEBUG_LEVEL >= 2
-        return const_iterator(static_cast<__node_const_pointer>(
-        pointer_traits<__node_base_pointer>::pointer_to(const_cast<__node_base&>(__end_))), this);
+        return const_iterator(_Caster::__from_element(const_cast<__node_base&>(__end_)), this);
 #else
-        return const_iterator(static_cast<__node_const_pointer>(
-        pointer_traits<__node_base_pointer>::pointer_to(const_cast<__node_base&>(__end_))));
+        return const_iterator(_Caster::__from_element(const_cast<__node_base&>(__end_)));
 #endif
     }
 

include/memory

 
 _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
+
+
+template <class _From, class _To>
+struct _FancyPointerCaster
+{
+  typedef pointer_traits<_From> _FromPtrTraits;
+  typedef typename _FromPtrTraits::element_type _Element;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static _To __from_element(_Element & __e)
+  {
+    return static_cast<_To>(_FromPtrTraits::pointer_to(__e));
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  static _To __from_pointer(_From & __f)
+  {
+    return static_cast<_To>(__f);
+  }
+};
+
+template <class _From, class _To>
+struct _FancyPointerCaster<_From*, _To>
+{
+  typedef pointer_traits<_From*> _FromPtrTraits;
+  typedef typename _FromPtrTraits::element_type _Element;
+
+  _LIBCPP_INLINE_VISIBILITY
+  static _To __from_element(_Element & __e)
+  {
+    return reinterpret_cast<_To>(_FromPtrTraits::pointer_to(__e));
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  static _To __from_pointer(_From * __f)
+  {
+    return reinterpret_cast<_To>(__f);
+  }
+};
+
+
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_MEMORY