blob: 8add02d946b3f3fc348a90544b709b79c03fbfbc (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef ATOMIC_HELPERS_H
#define ATOMIC_HELPERS_H
#include <cassert>
#include <cstdint>
#include "test_macros.h"
struct UserAtomicType {
int i;
explicit UserAtomicType(int d = 0) TEST_NOEXCEPT : i(d) {}
friend bool operator==(const UserAtomicType& x, const UserAtomicType& y) { return x.i == y.i; }
};
/*
Enable these once we have P0528
struct WeirdUserAtomicType
{
char i, j, k; // the 3 chars of doom
explicit WeirdUserAtomicType(int d = 0) TEST_NOEXCEPT : i(d) {}
friend bool operator==(const WeirdUserAtomicType& x, const WeirdUserAtomicType& y)
{ return x.i == y.i; }
};
struct PaddedUserAtomicType
{
char i; int j; // probably lock-free?
explicit PaddedUserAtomicType(int d = 0) TEST_NOEXCEPT : i(d) {}
friend bool operator==(const PaddedUserAtomicType& x, const PaddedUserAtomicType& y)
{ return x.i == y.i; }
};
*/
struct LargeUserAtomicType {
int a[128]; /* decidedly not lock-free */
LargeUserAtomicType(int d = 0) TEST_NOEXCEPT {
for (auto&& e : a)
e = d++;
}
friend bool operator==(LargeUserAtomicType const& x, LargeUserAtomicType const& y) TEST_NOEXCEPT {
for (int i = 0; i < 128; ++i)
if (x.a[i] != y.a[i])
return false;
return true;
}
};
template <template <class TestArg> class TestFunctor>
struct TestEachIntegralType {
void operator()() const {
TestFunctor<char>()();
TestFunctor<signed char>()();
TestFunctor<unsigned char>()();
TestFunctor<short>()();
TestFunctor<unsigned short>()();
TestFunctor<int>()();
TestFunctor<unsigned int>()();
TestFunctor<long>()();
TestFunctor<unsigned long>()();
TestFunctor<long long>()();
TestFunctor<unsigned long long>()();
TestFunctor<wchar_t>()();
#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
TestFunctor<char8_t>()();
#endif
TestFunctor<char16_t>()();
TestFunctor<char32_t>()();
TestFunctor<std::int8_t>()();
TestFunctor<std::uint8_t>()();
TestFunctor<std::int16_t>()();
TestFunctor<std::uint16_t>()();
TestFunctor<std::int32_t>()();
TestFunctor<std::uint32_t>()();
TestFunctor<std::int64_t>()();
TestFunctor<std::uint64_t>()();
}
};
template <template <class TestArg> class TestFunctor>
struct TestEachFloatingPointType {
void operator()() const {
TestFunctor<float>()();
TestFunctor<double>()();
TestFunctor<long double>()();
}
};
template <template <class TestArg> class TestFunctor>
struct TestEachPointerType {
void operator()() const {
TestFunctor<int*>()();
TestFunctor<const int*>()();
}
};
template <template <class TestArg> class TestFunctor>
struct TestEachAtomicType {
void operator()() const {
TestEachIntegralType<TestFunctor>()();
TestFunctor<UserAtomicType>()();
/*
Note: These aren't going to be lock-free,
so some libatomic.a is necessary. To handle
the case where the support functions are
missing, all tests that use this file should add:
XFAIL: !non-lockfree-atomics
*/
TestFunctor<LargeUserAtomicType>()();
/*
Enable these once we have P0528
TestFunctor<PaddedUserAtomicType>()();
TestFunctor<WeirdUserAtomicType>()();
*/
TestFunctor<int*>()();
TestFunctor<const int*>()();
TestFunctor<float>()();
TestFunctor<double>()();
}
};
#endif // ATOMIC_HELPERS_H
|
