[libc++] Tolerate presence of __deallocate macro

EricWF · EricWF · commit cd71f447b7d3 · 2017-01-07T03:01:24.000Z
Summary: On Windows the identifier `__deallocate` is defined as a macro by one of the Windows system headers. Previously libc++ worked around this by `#undef __deallocate` and generating a warning. However this causes the WIN32 version of `__threading_support` to always generate a warning on Windows. This is not OK. This patch renames all usages of `__deallocate` internally as to not conflict with the macro. Reviewers: mclow.lists, majnemer, rnk, rsmith, smeenai, compnerd Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28426 llvm-svn: 291332
diff --git a/libcxx/include/__hash_table b/libcxx/include/__hash_table
@@ -20,7 +20,6 @@
 #include <utility>
 
 #include <__undef_min_max>
-#include <__undef___deallocate>
 
 #include <__debug>
 
@@ -1321,7 +1320,7 @@ private:
         void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
 #endif // _LIBCPP_CXX03_LANG
 
-    void __deallocate(__next_pointer __np) _NOEXCEPT;
+    void __deallocate_node(__next_pointer __np) _NOEXCEPT;
     __next_pointer __detach() _NOEXCEPT;
 
     template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
@@ -1454,7 +1453,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
                  "Predicate must be copy-constructible.");
     static_assert((is_copy_constructible<hasher>::value),
                  "Hasher must be copy-constructible.");
-    __deallocate(__p1_.first().__next_);
+    __deallocate_node(__p1_.first().__next_);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__erase_c(this);
 #endif
@@ -1492,7 +1491,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u)
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__next_pointer __np)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np)
     _NOEXCEPT
 {
     __node_allocator& __na = __node_alloc();
@@ -1599,11 +1598,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
             }
             catch (...)
             {
-                __deallocate(__cache);
+                __deallocate_node(__cache);
                 throw;
             }
 #endif  // _LIBCPP_NO_EXCEPTIONS
-            __deallocate(__cache);
+            __deallocate_node(__cache);
         }
         const_iterator __i = __u.begin();
         while (__u.size() != 0)
@@ -1661,11 +1660,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first
         }
         catch (...)
         {
-            __deallocate(__cache);
+            __deallocate_node(__cache);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __deallocate(__cache);
+        __deallocate_node(__cache);
     }
     for (; __first != __last; ++__first)
         __insert_unique(*__first);
@@ -1701,11 +1700,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
         }
         catch (...)
         {
-            __deallocate(__cache);
+            __deallocate_node(__cache);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __deallocate(__cache);
+        __deallocate_node(__cache);
     }
     for (; __first != __last; ++__first)
         __insert_multi(_NodeTypes::__get_value(*__first));
@@ -1765,7 +1764,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
 {
     if (size() > 0)
     {
-        __deallocate(__p1_.first().__next_);
+        __deallocate_node(__p1_.first().__next_);
         __p1_.first().__next_ = nullptr;
         size_type __bc = bucket_count();
         for (size_type __i = 0; __i < __bc; ++__i)
diff --git a/libcxx/include/__sso_allocator b/libcxx/include/__sso_allocator
@@ -15,8 +15,6 @@
 #include <type_traits>
 #include <new>
 
-#include <__undef___deallocate>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
@@ -64,7 +62,7 @@ public:
         if (__p == (pointer)&buf_)
             __allocated_ = false;
         else
-            _VSTD::__deallocate(__p);
+            _VSTD::__libcpp_deallocate(__p);
     }
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}
 
diff --git a/libcxx/include/__undef___deallocate b/libcxx/include/__undef___deallocate
diff --git a/libcxx/include/experimental/dynarray b/libcxx/include/experimental/dynarray
@@ -11,9 +11,6 @@
 #ifndef _LIBCPP_DYNARRAY
 #define _LIBCPP_DYNARRAY
 
-#include <__config>
-#if _LIBCPP_STD_VER > 11
-
 /*
     dynarray synopsis
 
@@ -96,6 +93,8 @@ public:
 }}  // std::experimental
 
 */
+#include <__config>
+#if _LIBCPP_STD_VER > 11
 
 #include <__functional_base>
 #include <iterator>
@@ -104,8 +103,6 @@ public:
 #include <new>
 #include <algorithm>
 
-#include <__undef___deallocate>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
@@ -143,9 +140,9 @@ private:
         return static_cast<value_type *> (_VSTD::__allocate (sizeof(value_type) * count));
     }
 
-    static inline _LIBCPP_INLINE_VISIBILITY void __deallocate ( value_type* __ptr ) noexcept
+    static inline _LIBCPP_INLINE_VISIBILITY void __deallocate_value( value_type* __ptr ) noexcept
     {
-        _VSTD::__deallocate (static_cast<void *> (__ptr));
+        _VSTD::__libcpp_deallocate (static_cast<void *> (__ptr));
     }
 
 public:
@@ -265,7 +262,7 @@ dynarray<_Tp>::~dynarray()
     value_type *__data = data () + __size_;
     for ( size_t i = 0; i < __size_; ++i )
         (--__data)->value_type::~value_type();
-    __deallocate ( __base_ );
+    __deallocate_value( __base_ );
 }
 
 template <class _Tp>
diff --git a/libcxx/include/memory b/libcxx/include/memory
@@ -644,7 +644,6 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 #endif
 
 #include <__undef_min_max>
-#include <__undef___deallocate>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -1772,7 +1771,7 @@ public:
         return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));
         }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
-        {_VSTD::__deallocate((void*)__p);}
+        {_VSTD::__libcpp_deallocate((void*)__p);}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
@@ -1868,7 +1867,7 @@ public:
         return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));
     }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
-        {_VSTD::__deallocate((void*)__p);}
+        {_VSTD::__libcpp_deallocate((void*)__p);}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
@@ -485,7 +485,6 @@ module std [system] {
   module __tree { header "__tree" export * }
   module __tuple { header "__tuple" export * }
   module __undef_min_max { header "__undef_min_max" export * }
-  module __undef___deallocate { header "__undef___deallocate" export * }
 
   module experimental {
     requires cplusplus11
diff --git a/libcxx/include/new b/libcxx/include/new
@@ -92,8 +92,6 @@ void  operator delete[](void* ptr, void*) noexcept;
 #include <cstdlib>
 #endif
 
-#include <__undef___deallocate>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
@@ -217,7 +215,7 @@ inline _LIBCPP_INLINE_VISIBILITY void *__allocate(size_t __size) {
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY void __deallocate(void *__ptr) {
+inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate(void *__ptr) {
 #ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
   ::operator delete(__ptr);
 #else
diff --git a/libcxx/include/valarray b/libcxx/include/valarray
@@ -348,7 +348,6 @@ template <class T> unspecified2 end(const valarray<T>& v);
 #include <new>
 
 #include <__undef_min_max>
-#include <__undef___deallocate>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
@@ -3697,7 +3696,7 @@ valarray<_Tp>::resize(size_t __n, value_type __x)
     {
         while (__end_ != __begin_)
             (--__end_)->~value_type();
-        _VSTD::__deallocate(__begin_);
+        _VSTD::__libcpp_deallocate(__begin_);
         __begin_ = __end_ = nullptr;
     }
     if (__n)
diff --git a/libcxx/src/experimental/memory_resource.cpp b/libcxx/src/experimental/memory_resource.cpp
@@ -34,7 +34,7 @@ class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp
         { return __allocate(__size); }
 
     virtual void do_deallocate(void * __p, size_t, size_t)
-        { __deallocate(__p); }
+        { _VSTD::__libcpp_deallocate(__p); }
 
     virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
         { return &__other == this; }

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@`
`20`	`20`	`#include <utility>`
`21`	`21`
`22`	`22`	`#include <__undef_min_max>`
`23`		`-#include <__undef___deallocate>`
`24`	`23`
`25`	`24`	`#include <__debug>`
`26`	`25`
`@@ -1321,7 +1320,7 @@ private:`
`1321`	`1320`	`void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}`
`1322`	`1321`	`#endif // _LIBCPP_CXX03_LANG`
`1323`	`1322`
`1324`		`- void __deallocate(__next_pointer __np) _NOEXCEPT;`
	`1323`	`+ void __deallocate_node(__next_pointer __np) _NOEXCEPT;`
`1325`	`1324`	`__next_pointer __detach() _NOEXCEPT;`
`1326`	`1325`
`1327`	`1326`	`template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;`
`@@ -1454,7 +1453,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()`
`1454`	`1453`	`"Predicate must be copy-constructible.");`
`1455`	`1454`	`static_assert((is_copy_constructible<hasher>::value),`
`1456`	`1455`	`"Hasher must be copy-constructible.");`
`1457`		`- __deallocate(__p1_.first().__next_);`
	`1456`	`+ __deallocate_node(__p1_.first().__next_);`
`1458`	`1457`	`#if _LIBCPP_DEBUG_LEVEL >= 2`
`1459`	`1458`	`__get_db()->__erase_c(this);`
`1460`	`1459`	`#endif`
`@@ -1492,7 +1491,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u)`
`1492`	`1491`
`1493`	`1492`	`template <class _Tp, class _Hash, class _Equal, class _Alloc>`
`1494`	`1493`	`void`
`1495`		`-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__next_pointer __np)`
	`1494`	`+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np)`
`1496`	`1495`	`_NOEXCEPT`
`1497`	`1496`	`{`
`1498`	`1497`	`__node_allocator& __na = __node_alloc();`
`@@ -1599,11 +1598,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(`
`1599`	`1598`	`}`
`1600`	`1599`	`catch (...)`
`1601`	`1600`	`{`
`1602`		`- __deallocate(__cache);`
	`1601`	`+ __deallocate_node(__cache);`
`1603`	`1602`	`throw;`
`1604`	`1603`	`}`
`1605`	`1604`	`#endif // _LIBCPP_NO_EXCEPTIONS`
`1606`		`- __deallocate(__cache);`
	`1605`	`+ __deallocate_node(__cache);`
`1607`	`1606`	`}`
`1608`	`1607`	`const_iterator __i = __u.begin();`
`1609`	`1608`	`while (__u.size() != 0)`
`@@ -1661,11 +1660,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first`
`1661`	`1660`	`}`
`1662`	`1661`	`catch (...)`
`1663`	`1662`	`{`
`1664`		`- __deallocate(__cache);`
	`1663`	`+ __deallocate_node(__cache);`
`1665`	`1664`	`throw;`
`1666`	`1665`	`}`
`1667`	`1666`	`#endif // _LIBCPP_NO_EXCEPTIONS`
`1668`		`- __deallocate(__cache);`
	`1667`	`+ __deallocate_node(__cache);`
`1669`	`1668`	`}`
`1670`	`1669`	`for (; __first != __last; ++__first)`
`1671`	`1670`	`__insert_unique(*__first);`
`@@ -1701,11 +1700,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,`
`1701`	`1700`	`}`
`1702`	`1701`	`catch (...)`
`1703`	`1702`	`{`
`1704`		`- __deallocate(__cache);`
	`1703`	`+ __deallocate_node(__cache);`
`1705`	`1704`	`throw;`
`1706`	`1705`	`}`
`1707`	`1706`	`#endif // _LIBCPP_NO_EXCEPTIONS`
`1708`		`- __deallocate(__cache);`
	`1707`	`+ __deallocate_node(__cache);`
`1709`	`1708`	`}`
`1710`	`1709`	`for (; __first != __last; ++__first)`
`1711`	`1710`	`__insert_multi(_NodeTypes::__get_value(*__first));`
`@@ -1765,7 +1764,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT`
`1765`	`1764`	`{`
`1766`	`1765`	`if (size() > 0)`
`1767`	`1766`	`{`
`1768`		`- __deallocate(__p1_.first().__next_);`
	`1767`	`+ __deallocate_node(__p1_.first().__next_);`
`1769`	`1768`	`__p1_.first().__next_ = nullptr;`
`1770`	`1769`	`size_type __bc = bucket_count();`
`1771`	`1770`	`for (size_type __i = 0; __i < __bc; ++__i)`
Original file line number	Diff line number	Diff line change
`@@ -348,7 +348,6 @@ template <class T> unspecified2 end(const valarray<T>& v);`
`348`	`348`	`#include <new>`
`349`	`349`
`350`	`350`	`#include <__undef_min_max>`
`351`		`-#include <__undef___deallocate>`
`352`	`351`
`353`	`352`	`#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)`
`354`	`353`	`#pragma GCC system_header`
`@@ -3697,7 +3696,7 @@ valarray<_Tp>::resize(size_t __n, value_type __x)`
`3697`	`3696`	`{`
`3698`	`3697`	`while (__end_ != __begin_)`
`3699`	`3698`	`(--__end_)->~value_type();`
`3700`		`- _VSTD::__deallocate(__begin_);`
	`3699`	`+ _VSTD::__libcpp_deallocate(__begin_);`
`3701`	`3700`	`__begin_ = __end_ = nullptr;`
`3702`	`3701`	`}`
`3703`	`3702`	`if (__n)`