This is an archive of the discontinued LLVM Phabricator instance.

Differential D111564

[libc++] Use addressof to fix debug tests.
ClosedPublic

Authored by Mordante on Oct 11 2021, 10:47 AM.

Details

Reviewers
ldionne
• Quuxplusone
Group Reviewers
Restricted Project
Commits
rG968e27397caa: [libc++] Use addressof to fix debug tests.
Summary

Fixes the tests added in D110852 for the debug iterators.

Similar issues with hijacking operator& still exist, they will be
addressed separately.

Diff Detail

Event Timeline

Mordante requested review of this revision.Oct 11 2021, 10:47 AM
Mordante created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptOct 11 2021, 10:47 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
ldionne accepted this revision.Oct 11 2021, 10:52 AM
ldionne added a subscriber: ldionne.

LGTM pending CI!

This revision is now accepted and ready to land.Oct 11 2021, 10:52 AM
• Quuxplusone accepted this revision.Oct 11 2021, 11:05 AM
Harbormaster completed remote builds in B128156: Diff 378733.Oct 11 2021, 1:11 PM
Mordante updated this revision to Diff 379045.Oct 12 2021, 8:15 AM

Fix the CI.

Harbormaster completed remote builds in B128378: Diff 379045.Oct 12 2021, 9:14 AM
Closed by commit rG968e27397caa: [libc++] Use addressof to fix debug tests. (authored by Mordante). · Explain WhyOct 12 2021, 9:15 AM
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rG968e27397caa: [libc++] Use addressof to fix debug tests..

Revision Contents

PathSize
libcxx/
include/
2 lines
16 lines
16 lines
test/
std/
containers/
sequences/
list/
list.cons/
3 lines
unord/
unord.map/
unord.map.cnstr/
3 lines
unord.multimap/
unord.multimap.cnstr/
3 lines
unord.multiset/
unord.multiset.cnstr/
3 lines
unord.set/
unord.set.cnstr/
3 lines

Diff 379074

libcxx/include/__hash_table

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Lines
#endif #endif
} }
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__hash_iterator(const __hash_iterator& __i) __hash_iterator(const __hash_iterator& __i)
: __node_(__i.__node_) : __node_(__i.__node_)
{ {
__get_db()->__iterator_copy(this, &__i); __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~__hash_iterator() ~__hash_iterator()
{ {
__get_db()->__erase_i(this); __get_db()->__erase_i(this);
} }
▲ Show 20 Lines • Show All 2,504 Lines • Show Last 20 Lines

libcxx/include/list

Show First 20 Lines • Show All 324 Lines • ▼ Show 20 Lines#endif
} }
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__list_iterator(const __list_iterator& __p) __list_iterator(const __list_iterator& __p)
: __ptr_(__p.__ptr_) : __ptr_(__p.__ptr_)
{ {
__get_db()->__iterator_copy(this, &__p); __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~__list_iterator() ~__list_iterator()
{ {
__get_db()->__erase_i(this); __get_db()->__erase_i(this);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__list_iterator& operator=(const __list_iterator& __p) __list_iterator& operator=(const __list_iterator& __p)
{ {
if (this != &__p) if (this != _VSTD::addressof(__p))
{ {
__get_db()->__iterator_copy(this, &__p); __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
__ptr_ = __p.__ptr_; __ptr_ = __p.__ptr_;
} }
return *this; return *this;
} }
#endif // _LIBCPP_DEBUG_LEVEL == 2 #endif // _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines#if _LIBCPP_DEBUG_LEVEL == 2
__get_db()->__insert_i(this); __get_db()->__insert_i(this);
#endif #endif
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT __list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT
: __ptr_(__p.__ptr_) : __ptr_(__p.__ptr_)
{ {
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
__get_db()->__iterator_copy(this, &__p); __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
#endif #endif
} }
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__list_const_iterator(const __list_const_iterator& __p) __list_const_iterator(const __list_const_iterator& __p)
: __ptr_(__p.__ptr_) : __ptr_(__p.__ptr_)
{ {
__get_db()->__iterator_copy(this, &__p); __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
~__list_const_iterator() ~__list_const_iterator()
{ {
__get_db()->__erase_i(this); __get_db()->__erase_i(this);
} }
▲ Show 20 Lines • Show All 1,061 Lines • ▼ Show 20 Lines
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
template <class _InpIter> template <class _InpIter>
typename list<_Tp, _Alloc>::iterator typename list<_Tp, _Alloc>::iterator
list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l, list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*) typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*)
{ {
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
"list::insert(iterator, range) called with an iterator not" "list::insert(iterator, range) called with an iterator not"
" referring to this list"); " referring to this list");
iterator __r(__p.__ptr_, this); iterator __r(__p.__ptr_, this);
#else #else
iterator __r(__p.__ptr_); iterator __r(__p.__ptr_);
#endif #endif
if (__f != __l) if (__f != __l)
{ {
▲ Show 20 Lines • Show All 289 Lines • ▼ Show 20 Lines
#endif #endif
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
typename list<_Tp, _Alloc>::iterator typename list<_Tp, _Alloc>::iterator
list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l) list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l)
{ {
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == this, _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__f)) == this,
"list::erase(iterator, iterator) called with an iterator not" "list::erase(iterator, iterator) called with an iterator not"
" referring to this list"); " referring to this list");
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__l) == this, _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__l)) == this,
"list::erase(iterator, iterator) called with an iterator not" "list::erase(iterator, iterator) called with an iterator not"
" referring to this list"); " referring to this list");
#endif #endif
if (__f != __l) if (__f != __l)
{ {
__node_allocator& __na = base::__node_alloc(); __node_allocator& __na = base::__node_alloc();
base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_); base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_);
while (__f != __l) while (__f != __l)
▲ Show 20 Lines • Show All 638 Lines • Show Last 20 Lines

libcxx/include/unordered_map

Show First 20 Lines • Show All 1,442 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void rehash(size_type __n) {__table_.rehash(__n);} void rehash(size_type __n) {__table_.rehash(__n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void reserve(size_type __n) {__table_.reserve(__n);} void reserve(size_type __n) {__table_.reserve(__n);}
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
bool __dereferenceable(const const_iterator* __i) const bool __dereferenceable(const const_iterator* __i) const
{return __table_.__dereferenceable(&__i->__i_);} {return __table_.__dereferenceable(_VSTD::addressof(__i->__i_));}
bool __decrementable(const const_iterator* __i) const bool __decrementable(const const_iterator* __i) const
{return __table_.__decrementable(&__i->__i_);} {return __table_.__decrementable(_VSTD::addressof(__i->__i_));}
bool __addable(const const_iterator* __i, ptrdiff_t __n) const bool __addable(const const_iterator* __i, ptrdiff_t __n) const
{return __table_.__addable(&__i->__i_, __n);} {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
{return __table_.__addable(&__i->__i_, __n);} {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
#endif // _LIBCPP_DEBUG_LEVEL == 2 #endif // _LIBCPP_DEBUG_LEVEL == 2
private: private:
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
__node_holder __construct_node_with_key(const key_type& __k); __node_holder __construct_node_with_key(const key_type& __k);
#endif #endif
▲ Show 20 Lines • Show All 779 Lines • ▼ Show 20 Lines#endif // _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void rehash(size_type __n) {__table_.rehash(__n);} void rehash(size_type __n) {__table_.rehash(__n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void reserve(size_type __n) {__table_.reserve(__n);} void reserve(size_type __n) {__table_.reserve(__n);}
#if _LIBCPP_DEBUG_LEVEL == 2 #if _LIBCPP_DEBUG_LEVEL == 2
bool __dereferenceable(const const_iterator* __i) const bool __dereferenceable(const const_iterator* __i) const
{return __table_.__dereferenceable(&__i->__i_);} {return __table_.__dereferenceable(_VSTD::addressof(__i->__i_));}
bool __decrementable(const const_iterator* __i) const bool __decrementable(const const_iterator* __i) const
{return __table_.__decrementable(&__i->__i_);} {return __table_.__decrementable(_VSTD::addressof(__i->__i_));}
bool __addable(const const_iterator* __i, ptrdiff_t __n) const bool __addable(const const_iterator* __i, ptrdiff_t __n) const
{return __table_.__addable(&__i->__i_, __n);} {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
{return __table_.__addable(&__i->__i_, __n);} {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
#endif // _LIBCPP_DEBUG_LEVEL == 2 #endif // _LIBCPP_DEBUG_LEVEL == 2
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template<class _InputIterator, template<class _InputIterator,
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

libcxx/test/std/containers/sequences/list/list.cons/assign_copy.addressof.compile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Guard the debug iterators against ADL-hijacking.
// XFAIL: LIBCXX-DEBUG-FIXME
// <list> // <list>
// list& operator=(const list& c); // list& operator=(const list& c);
// Validate whether the container can be copy-assigned with an ADL-hijacking operator& // Validate whether the container can be copy-assigned with an ADL-hijacking operator&
#include <list> #include <list>
#include "test_macros.h" #include "test_macros.h"
#include "operator_hijacker.h" #include "operator_hijacker.h"
void test() { void test() {
std::list<operator_hijacker> lo; std::list<operator_hijacker> lo;
std::list<operator_hijacker> l; std::list<operator_hijacker> l;
l = lo; l = lo;
} }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.addressof.compile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Guard the debug iterators against ADL-hijacking.
// XFAIL: LIBCXX-DEBUG-FIXME
// <unordered_map> // <unordered_map>
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// unordered_map& operator=(const unordered_map& u); // unordered_map& operator=(const unordered_map& u);
Show All 19 Lines

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.addressof.compile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Guard the debug iterators against ADL-hijacking.
// XFAIL: LIBCXX-DEBUG-FIXME
// <unordered_map> // <unordered_map>
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// unordered_multimap& operator=(const unordered_multimap& u); // unordered_multimap& operator=(const unordered_multimap& u);
Show All 19 Lines

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.addressof.compile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Guard the debug iterators against ADL-hijacking.
// XFAIL: LIBCXX-DEBUG-FIXME
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// unordered_multiset& operator=(const unordered_multiset& u); // unordered_multiset& operator=(const unordered_multiset& u);
Show All 12 Lines

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.addressof.compile.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Guard the debug iterators against ADL-hijacking.
// XFAIL: LIBCXX-DEBUG-FIXME
// <unordered_set> // <unordered_set>
// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// unordered_set& operator=(const unordered_set& u); // unordered_set& operator=(const unordered_set& u);
Show All 12 Lines