blob: dc200cf572bfec30f904e0754f89984aff1b18af (
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
142
143
144
145
146
147
|
//===----------------------------- test_guard.cpp -------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "cxxabi.h"
#include <cassert>
#ifndef _LIBCXXABI_HAS_NO_THREADS
#include <thread>
#endif
// Ensure that we initialize each variable once and only once.
namespace test1 {
static int run_count = 0;
int increment() {
++run_count;
return 0;
}
void helper() {
static int a = increment();
((void)a);
}
void test() {
static int a = increment(); ((void)a);
assert(run_count == 1);
static int b = increment(); ((void)b);
assert(run_count == 2);
helper();
assert(run_count == 3);
helper();
assert(run_count == 3);
}
}
// When initialization fails, ensure that we try to initialize it again next
// time.
namespace test2 {
#ifndef LIBCXXABI_HAS_NO_EXCEPTIONS
static int run_count = 0;
int increment() {
++run_count;
throw 0;
}
void helper() {
try {
static int a = increment();
assert(false);
((void)a);
} catch (...) {}
}
void test() {
helper();
assert(run_count == 1);
helper();
assert(run_count == 2);
}
#else
void test() {}
#endif
}
// Check that we can initialize a second value while initializing a first.
namespace test3 {
int zero() {
return 0;
}
int one() {
static int b = zero(); ((void)b);
return 0;
}
void test() {
static int a = one(); ((void)a);
}
}
#ifndef _LIBCXXABI_HAS_NO_THREADS
// A simple thread test of two threads racing to initialize a variable. This
// isn't guaranteed to catch any particular threading problems.
namespace test4 {
static int run_count = 0;
int increment() {
++run_count;
return 0;
}
void helper() {
static int a = increment(); ((void)a);
}
void test() {
std::thread t1(helper), t2(helper);
t1.join();
t2.join();
assert(run_count == 1);
}
}
// Check that we don't re-initialize a static variable even when it's
// encountered from two different threads.
namespace test5 {
static int run_count = 0;
int zero() {
++run_count;
return 0;
}
int one() {
static int b = zero(); ((void)b);
return 0;
}
void another_helper() {
static int a = one(); ((void)a);
}
void helper() {
static int a = one(); ((void)a);
std::thread t(another_helper);
t.join();
}
void test() {
std::thread t(helper);
t.join();
assert(run_count == 1);
}
}
#endif /* _LIBCXXABI_HAS_NO_THREADS */
int main()
{
test1::test();
test2::test();
test3::test();
#ifndef _LIBCXXABI_HAS_NO_THREADS
test4::test();
test5::test();
#endif
}
|
