1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <gtest/gtest.h>
18 #include <stdint.h>
19 #include <string.h>
20
21 #if defined(__GNUC__) && !defined(__clang__) && \
22 (defined(__arm__) || defined(__aarch64__))
23 // Gcc has a bug with -O -fdata-section for the arm target: http://b/22772147.
24 // Until that bug is fixed, disable optimization since
25 // it is not essential for this test.
26 #pragma GCC optimize("-O0")
27 #endif
28
29 __thread int local_var = 100;
30 int shared_var = 200;
31
reset_vars()32 static void reset_vars() {
33 local_var = 1000;
34 shared_var = 2000;
35 // local_var should be reset by threads
36 }
37
38 typedef void* (*MyThread)(void*);
39
inc_shared_var(void * p)40 static void* inc_shared_var(void* p) {
41 int *data = reinterpret_cast<int*>(p);
42 shared_var++;
43 *data = shared_var;
44 return nullptr;
45 }
46
inc_local_var(void * p)47 static void* inc_local_var(void* p) {
48 int *data = reinterpret_cast<int*>(p);
49 local_var++;
50 *data = local_var;
51 return nullptr;
52 }
53
run_one_thread(MyThread foo)54 static int run_one_thread(MyThread foo) {
55 pthread_t t;
56 int data;
57 int error = pthread_create(&t, nullptr, foo, &data);
58 if (!error)
59 error = pthread_join(t, nullptr);
60 return error ? error : data;
61 }
62
TEST(thread_local_storage,shared)63 TEST(thread_local_storage, shared) {
64 reset_vars();
65 ASSERT_EQ(local_var, 1000);
66 ASSERT_EQ(shared_var, 2000);
67
68 // Update shared_var, local_var remains 1000.
69 ASSERT_EQ(run_one_thread(inc_shared_var), 2001);
70 ASSERT_EQ(local_var, 1000);
71 ASSERT_EQ(shared_var, 2001);
72
73 ASSERT_EQ(run_one_thread(inc_shared_var), 2002);
74 ASSERT_EQ(local_var, 1000);
75 ASSERT_EQ(shared_var, 2002);
76
77 ASSERT_EQ(run_one_thread(inc_shared_var), 2003);
78 ASSERT_EQ(local_var, 1000);
79 ASSERT_EQ(shared_var, 2003);
80 }
81
TEST(thread_local_storage,local)82 TEST(thread_local_storage, local) {
83 reset_vars();
84 ASSERT_EQ(local_var, 1000);
85 ASSERT_EQ(shared_var, 2000);
86
87 // When a child thread updates its own TLS variable,
88 // this thread's local_var and shared_var are not changed.
89 // TLS local_var is initialized to 100 in a thread.
90 ASSERT_EQ(run_one_thread(inc_local_var), 101);
91 ASSERT_EQ(local_var, 1000);
92 ASSERT_EQ(shared_var, 2000);
93
94 ASSERT_EQ(run_one_thread(inc_local_var), 101);
95 ASSERT_EQ(local_var, 1000);
96 ASSERT_EQ(shared_var, 2000);
97
98 ASSERT_EQ(run_one_thread(inc_local_var), 101);
99 ASSERT_EQ(local_var, 1000);
100 ASSERT_EQ(shared_var, 2000);
101 }
102
103 // Test TLS initialization of more complicated type, array of struct.
104 struct Point {
105 int x, y;
106 };
107
108 typedef Point Triangle[3];
109
110 __thread Triangle local_triangle = {{10,10}, {20,20}, {30,30}};
111 Triangle shared_triangle = {{1,1}, {2,2}, {3,3}};
112
reset_triangle()113 static void reset_triangle() {
114 static const Triangle t1 = {{3,3}, {4,4}, {5,5}};
115 static const Triangle t2 = {{2,2}, {3,3}, {4,4}};
116 memcpy(local_triangle, t1, sizeof(local_triangle));
117 memcpy(shared_triangle, t2, sizeof(shared_triangle));
118 }
119
move_shared_triangle(void * p)120 static void* move_shared_triangle(void* p) {
121 int *data = reinterpret_cast<int*>(p);
122 shared_triangle[1].y++;
123 *data = shared_triangle[1].y;
124 return nullptr;
125 }
126
move_local_triangle(void * p)127 static void* move_local_triangle(void* p) {
128 int *data = reinterpret_cast<int*>(p);
129 local_triangle[1].y++;
130 *data = local_triangle[1].y;
131 return nullptr;
132 }
133
TEST(thread_local_storage,shared_triangle)134 TEST(thread_local_storage, shared_triangle) {
135 reset_triangle();
136 ASSERT_EQ(local_triangle[1].y, 4);
137 ASSERT_EQ(shared_triangle[1].y, 3);
138
139 // Update shared_triangle, local_triangle remains 1000.
140 ASSERT_EQ(run_one_thread(move_shared_triangle), 4);
141 ASSERT_EQ(local_triangle[1].y, 4);
142 ASSERT_EQ(shared_triangle[1].y, 4);
143
144 ASSERT_EQ(run_one_thread(move_shared_triangle), 5);
145 ASSERT_EQ(local_triangle[1].y, 4);
146 ASSERT_EQ(shared_triangle[1].y, 5);
147
148 ASSERT_EQ(run_one_thread(move_shared_triangle), 6);
149 ASSERT_EQ(local_triangle[1].y, 4);
150 ASSERT_EQ(shared_triangle[1].y, 6);
151 }
152
TEST(thread_local_storage,local_triangle)153 TEST(thread_local_storage, local_triangle) {
154 reset_triangle();
155 ASSERT_EQ(local_triangle[1].y, 4);
156 ASSERT_EQ(shared_triangle[1].y, 3);
157
158 // Update local_triangle, parent thread's
159 // shared_triangle and local_triangle are unchanged.
160 ASSERT_EQ(run_one_thread(move_local_triangle), 21);
161 ASSERT_EQ(local_triangle[1].y, 4);
162 ASSERT_EQ(shared_triangle[1].y, 3);
163
164 ASSERT_EQ(run_one_thread(move_local_triangle), 21);
165 ASSERT_EQ(local_triangle[1].y, 4);
166 ASSERT_EQ(shared_triangle[1].y, 3);
167
168 ASSERT_EQ(run_one_thread(move_local_triangle), 21);
169 ASSERT_EQ(local_triangle[1].y, 4);
170 ASSERT_EQ(shared_triangle[1].y, 3);
171 }
172
173 // Test emutls runtime data structures and __emutls_get_address function.
174 typedef unsigned int gcc_word __attribute__((mode(word)));
175 typedef unsigned int gcc_pointer __attribute__((mode(pointer)));
176 struct gcc_emutls_object { // for libgcc
177 gcc_word size;
178 gcc_word align;
179 union {
180 gcc_pointer offset;
181 void* ptr;
182 } loc;
183 void* templ;
184 };
185
186 typedef struct __emutls_control { // for clang/llvm
187 size_t size;
188 size_t align;
189 union {
190 uintptr_t index;
191 void* address;
192 } object;
193 void* value;
194 } __emutls_control;
195
TEST(thread_local_storage,type_size)196 TEST(thread_local_storage, type_size) {
197 static_assert(sizeof(size_t) == sizeof(gcc_word),
198 "size_t != gcc_word");
199 static_assert(sizeof(uintptr_t) == sizeof(gcc_pointer),
200 "uintptr_t != gcc_pointer");
201 static_assert(sizeof(uintptr_t) == sizeof(void*),
202 "sizoeof(uintptr_t) != sizeof(void*)");
203 static_assert(sizeof(__emutls_control) == sizeof(struct gcc_emutls_object),
204 "sizeof(__emutls_control) != sizeof(struct gcc_emutls_object)");
205 }
206
207 extern "C" void* __emutls_get_address(__emutls_control*);
208
TEST(thread_local_storage,init_value)209 TEST(thread_local_storage, init_value) {
210 char tls_value1[] = "123456789";
211 char tls_value2[] = "abcdefghi";
212 constexpr size_t num_saved_values = 10;
213 __emutls_control tls_var[num_saved_values];
214 size_t prev_index = 0;
215 void* saved_gap[num_saved_values];
216 void* saved_p[num_saved_values];
217 ASSERT_TRUE(strlen(tls_value2) <= strlen(tls_value1));
218 __emutls_control c =
219 {strlen(tls_value1) + 1, 1, {0}, tls_value1};
220 for (size_t n = 0; n < num_saved_values; n++) {
221 memcpy(&tls_var[n], &c, sizeof(c));
222 tls_var[n].align = (1 << n);
223 }
224 for (size_t n = 0; n < num_saved_values; n++) {
225 // Try to mess up malloc space so that the next malloc will not have the
226 // required alignment, but __emutls_get_address should still return an
227 // aligned address.
228 saved_gap[n] = malloc(1);
229 void* p = __emutls_get_address(&tls_var[n]);
230 saved_p[n] = p;
231 ASSERT_TRUE(p != nullptr);
232 ASSERT_TRUE(tls_var[n].object.index != 0);
233 // check if p is a new object.
234 if (n > 0) {
235 // In single-thread environment, object.address == p.
236 // In multi-threads environment, object.index is increased.
237 ASSERT_TRUE(prev_index + 1 == tls_var[n].object.index ||
238 p == tls_var[n].object.address);
239 ASSERT_TRUE(p != saved_p[n - 1]);
240 }
241 prev_index = tls_var[n].object.index;
242 // check if p is aligned
243 uintptr_t align = (1 << n);
244 uintptr_t address= reinterpret_cast<uintptr_t>(p);
245 ASSERT_EQ((address & ~(align - 1)), address);
246 // check if *p is initialized
247 ASSERT_STREQ(tls_value1, static_cast<char*>(p));
248 // change value in *p
249 memcpy(p, tls_value2, strlen(tls_value2) + 1);
250 }
251 for (size_t n = 0; n < num_saved_values; n++) {
252 free(saved_gap[n]);
253 }
254 for (size_t n = 0; n < num_saved_values; n++) {
255 void* p = __emutls_get_address(&tls_var[n]);
256 ASSERT_EQ(p, saved_p[n]);
257 // check if *p has the new value
258 ASSERT_STREQ(tls_value2, static_cast<char*>(p));
259 }
260 }
261