-
Notifications
You must be signed in to change notification settings - Fork 11.6k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
[libc++] Add ABI tests for unordered_{map,set} (#107200)
These are used to ensure #76756 is correct.
- Loading branch information
1 parent
b44d9e5
commit fa38527
Showing
3 changed files
with
267 additions
and
0 deletions.
There are no files selected for viewing
134 changes: 134 additions & 0 deletions
134
libcxx/test/libcxx/containers/associative/unord.map/abi.compile.pass.cpp
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,134 @@ | ||
//===----------------------------------------------------------------------===// | ||
// | ||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||
// See https://llvm.org/LICENSE.txt for license information. | ||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||
// | ||
//===----------------------------------------------------------------------===// | ||
|
||
// UNSUPPORTED: libcpp-has-abi-fix-unordered-container-size-type | ||
|
||
#include <cstdint> | ||
#include <unordered_map> | ||
|
||
#include "min_allocator.h" | ||
#include "test_allocator.h" | ||
#include "test_macros.h" | ||
|
||
template <class T> | ||
class small_pointer { | ||
std::uint16_t offset; | ||
}; | ||
|
||
template <class T> | ||
class small_iter_allocator { | ||
public: | ||
using value_type = T; | ||
using pointer = small_pointer<T>; | ||
using size_type = std::uint16_t; | ||
using difference_type = std::int16_t; | ||
|
||
small_iter_allocator() TEST_NOEXCEPT {} | ||
|
||
template <class U> | ||
small_iter_allocator(small_iter_allocator<U>) TEST_NOEXCEPT {} | ||
|
||
T* allocate(std::size_t n); | ||
void deallocate(T* p, std::size_t); | ||
|
||
friend bool operator==(small_iter_allocator, small_iter_allocator) { return true; } | ||
friend bool operator!=(small_iter_allocator, small_iter_allocator) { return false; } | ||
}; | ||
|
||
template <class T> | ||
class final_small_iter_allocator final { | ||
public: | ||
using value_type = T; | ||
using pointer = small_pointer<T>; | ||
using size_type = std::uint16_t; | ||
using difference_type = std::int16_t; | ||
|
||
final_small_iter_allocator() TEST_NOEXCEPT {} | ||
|
||
template <class U> | ||
final_small_iter_allocator(final_small_iter_allocator<U>) TEST_NOEXCEPT {} | ||
|
||
T* allocate(std::size_t n); | ||
void deallocate(T* p, std::size_t); | ||
|
||
friend bool operator==(final_small_iter_allocator, final_small_iter_allocator) { return true; } | ||
friend bool operator!=(final_small_iter_allocator, final_small_iter_allocator) { return false; } | ||
}; | ||
|
||
template <class T, class Alloc> | ||
using unordered_map_alloc = std::unordered_map<T, T, std::hash<T>, std::equal_to<T>, Alloc>; | ||
|
||
#if __SIZE_WIDTH__ == 64 | ||
|
||
static_assert(sizeof(unordered_map_alloc<int, std::allocator<std::pair<const int, int> > >) == 40, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, min_allocator<std::pair<const int, int> > >) == 40, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, test_allocator<std::pair<const int, int> > >) == 64, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, small_iter_allocator<std::pair<const int, int> > >) == 12, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, final_small_iter_allocator<std::pair<const int, int> > >) == 16, ""); | ||
|
||
static_assert(sizeof(unordered_map_alloc<char, std::allocator<std::pair<const char, char> > >) == 40, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, min_allocator<std::pair<const char, char> > >) == 40, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, test_allocator<std::pair<const char, char> > >) == 64, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, small_iter_allocator<std::pair<const char, char> > >) == 12, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, final_small_iter_allocator<std::pair<const char, char> > >) == 16, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, std::allocator<std::pair<const int, int> > >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, min_allocator<std::pair<const int, int> > >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, test_allocator<std::pair<const int, int> > >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, small_iter_allocator<std::pair<const int, int> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, final_small_iter_allocator<std::pair<const int, int> > >) == 4, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, std::allocator<std::pair<const char, char> > >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, min_allocator<std::pair<const char, char> > >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, test_allocator<std::pair<const char, char> > >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, small_iter_allocator<std::pair<const char, char> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, final_small_iter_allocator<std::pair<const char, char> > >) == 4, | ||
""); | ||
|
||
struct TEST_ALIGNAS(32) AlignedHash {}; | ||
struct UnalignedEqualTo {}; | ||
|
||
static_assert(sizeof(std::unordered_map<int, int, AlignedHash, UnalignedEqualTo>) == 96, ""); | ||
static_assert(TEST_ALIGNOF(std::unordered_map<int, int, AlignedHash, UnalignedEqualTo>) == 32, ""); | ||
|
||
#elif __SIZE_WIDTH__ == 32 | ||
|
||
static_assert(sizeof(unordered_map_alloc<int, std::allocator<std::pair<const int, int> > >) == 20, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, min_allocator<std::pair<const int, int> > >) == 20, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, test_allocator<std::pair<const int, int> > >) == 44, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, small_iter_allocator<std::pair<const int, int> > >) == 12, ""); | ||
static_assert(sizeof(unordered_map_alloc<int, final_small_iter_allocator<std::pair<const int, int> > >) == 16, ""); | ||
|
||
static_assert(sizeof(unordered_map_alloc<char, std::allocator<std::pair<const char, char> > >) == 20, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, min_allocator<std::pair<const char, char> > >) == 20, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, test_allocator<std::pair<const char, char> > >) == 44, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, small_iter_allocator<std::pair<const char, char> > >) == 12, ""); | ||
static_assert(sizeof(unordered_map_alloc<char, final_small_iter_allocator<std::pair<const char, char> > >) == 16, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, std::allocator<std::pair<const int, int> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, min_allocator<std::pair<const int, int> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, test_allocator<std::pair<const int, int> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, small_iter_allocator<std::pair<const int, int> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<int, final_small_iter_allocator<std::pair<const int, int> > >) == 4, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, std::allocator<std::pair<const char, char> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, min_allocator<std::pair<const char, char> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, test_allocator<std::pair<const char, char> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, small_iter_allocator<std::pair<const char, char> > >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_map_alloc<char, final_small_iter_allocator<std::pair<const char, char> > >) == 4, | ||
""); | ||
|
||
struct TEST_ALIGNAS(32) AlignedHash {}; | ||
struct UnalignedEqualTo {}; | ||
|
||
static_assert(sizeof(std::unordered_map<int, int, AlignedHash, UnalignedEqualTo>) == 96); | ||
static_assert(TEST_ALIGNOF(std::unordered_map<int, int, AlignedHash, UnalignedEqualTo>) == 32); | ||
|
||
#else | ||
# error std::size_t has an unexpected size | ||
#endif |
132 changes: 132 additions & 0 deletions
132
libcxx/test/libcxx/containers/associative/unord.set/abi.compile.pass.cpp
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,132 @@ | ||
//===----------------------------------------------------------------------===// | ||
// | ||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||
// See https://llvm.org/LICENSE.txt for license information. | ||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||
// | ||
//===----------------------------------------------------------------------===// | ||
|
||
// UNSUPPORTED: libcpp-has-abi-fix-unordered-container-size-type | ||
|
||
#include <cstdint> | ||
#include <unordered_set> | ||
|
||
#include "min_allocator.h" | ||
#include "test_allocator.h" | ||
#include "test_macros.h" | ||
|
||
template <class T> | ||
class small_pointer { | ||
std::uint16_t offset; | ||
}; | ||
|
||
template <class T> | ||
class small_iter_allocator { | ||
public: | ||
using value_type = T; | ||
using pointer = small_pointer<T>; | ||
using size_type = std::uint16_t; | ||
using difference_type = std::int16_t; | ||
|
||
small_iter_allocator() TEST_NOEXCEPT {} | ||
|
||
template <class U> | ||
small_iter_allocator(small_iter_allocator<U>) TEST_NOEXCEPT {} | ||
|
||
T* allocate(std::size_t n); | ||
void deallocate(T* p, std::size_t); | ||
|
||
friend bool operator==(small_iter_allocator, small_iter_allocator) { return true; } | ||
friend bool operator!=(small_iter_allocator, small_iter_allocator) { return false; } | ||
}; | ||
|
||
template <class T> | ||
class final_small_iter_allocator final { | ||
public: | ||
using value_type = T; | ||
using pointer = small_pointer<T>; | ||
using size_type = std::uint16_t; | ||
using difference_type = std::int16_t; | ||
|
||
final_small_iter_allocator() TEST_NOEXCEPT {} | ||
|
||
template <class U> | ||
final_small_iter_allocator(final_small_iter_allocator<U>) TEST_NOEXCEPT {} | ||
|
||
T* allocate(std::size_t n); | ||
void deallocate(T* p, std::size_t); | ||
|
||
friend bool operator==(final_small_iter_allocator, final_small_iter_allocator) { return true; } | ||
friend bool operator!=(final_small_iter_allocator, final_small_iter_allocator) { return false; } | ||
}; | ||
|
||
template <class T, class Alloc> | ||
using unordered_set_alloc = std::unordered_set<T, std::hash<T>, std::equal_to<T>, Alloc>; | ||
|
||
#if __SIZE_WIDTH__ == 64 | ||
|
||
static_assert(sizeof(unordered_set_alloc<int, std::allocator<int> >) == 40, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, min_allocator<int> >) == 40, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, test_allocator<int> >) == 64, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, small_iter_allocator<int> >) == 12, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, final_small_iter_allocator<int> >) == 16, ""); | ||
|
||
static_assert(sizeof(unordered_set_alloc<char, std::allocator<char> >) == 40, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, min_allocator<char> >) == 40, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, test_allocator<char> >) == 64, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, small_iter_allocator<char> >) == 12, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, final_small_iter_allocator<char> >) == 16, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, std::allocator<int> >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, min_allocator<int> >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, test_allocator<int> >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, small_iter_allocator<int> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, final_small_iter_allocator<int> >) == 4, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, std::allocator<char> >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, min_allocator<char> >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, test_allocator<char> >) == 8, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, small_iter_allocator<char> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, final_small_iter_allocator<char> >) == 4, ""); | ||
|
||
struct TEST_ALIGNAS(32) AlignedHash {}; | ||
struct UnalignedEqualTo {}; | ||
|
||
static_assert(sizeof(std::unordered_set<int, AlignedHash, UnalignedEqualTo>) == 96, ""); | ||
static_assert(TEST_ALIGNOF(std::unordered_set<int, AlignedHash, UnalignedEqualTo>) == 32, ""); | ||
|
||
#elif __SIZE_WIDTH__ == 32 | ||
|
||
static_assert(sizeof(unordered_set_alloc<int, std::allocator<int> >) == 20, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, min_allocator<int> >) == 20, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, test_allocator<int> >) == 44, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, small_iter_allocator<int> >) == 12, ""); | ||
static_assert(sizeof(unordered_set_alloc<int, final_small_iter_allocator<int> >) == 16, ""); | ||
|
||
static_assert(sizeof(unordered_set_alloc<char, std::allocator<char> >) == 20, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, min_allocator<char> >) == 20, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, test_allocator<char> >) == 44, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, small_iter_allocator<char> >) == 12, ""); | ||
static_assert(sizeof(unordered_set_alloc<char, final_small_iter_allocator<char> >) == 16, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, std::allocator<int> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, min_allocator<int> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, test_allocator<int> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, small_iter_allocator<int> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<int, final_small_iter_allocator<int> >) == 4, ""); | ||
|
||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, std::allocator<char> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, min_allocator<char> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, test_allocator<char> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, small_iter_allocator<char> >) == 4, ""); | ||
static_assert(TEST_ALIGNOF(unordered_set_alloc<char, final_small_iter_allocator<char> >) == 4, ""); | ||
|
||
struct TEST_ALIGNAS(32) AlignedHash {}; | ||
struct UnalignedEqualTo {}; | ||
|
||
static_assert(sizeof(std::unordered_set<int, AlignedHash, UnalignedEqualTo>) == 96); | ||
static_assert(TEST_ALIGNOF(std::unordered_set<int, AlignedHash, UnalignedEqualTo>) == 32); | ||
|
||
#else | ||
# error std::size_t has an unexpected size | ||
#endif |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters