contrib/compiler-rt/lib/builtins/emutls.c

   1 /* ===---------- emutls.c - Implements __emutls_get_address ---------------===
   2  *
   3  *                     The LLVM Compiler Infrastructure
   4  *
   5  * This file is dual licensed under the MIT and the University of Illinois Open
   6  * Source Licenses. See LICENSE.TXT for details.
   7  *
   8  * ===----------------------------------------------------------------------===
   9  */
  10 #include <stdint.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "int_lib.h"
  15 #include "int_util.h"
  16
  17 #ifdef __BIONIC__
  18 /* There are 4 pthread key cleanup rounds on Bionic. Delay emutls deallocation
  19    to round 2. We need to delay deallocation because:
  20     - Android versions older than M lack __cxa_thread_atexit_impl, so apps
  21       use a pthread key destructor to call C++ destructors.
  22     - Apps might use __thread/thread_local variables in pthread destructors.
  23    We can't wait until the final two rounds, because jemalloc needs two rounds
  24    after the final malloc/free call to free its thread-specific data (see
  25    https://reviews.llvm.org/D46978#1107507). */
  26 #define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 1
  27 #else
  28 #define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 0
  29 #endif
  30
  31 typedef struct emutls_address_array {
  32     uintptr_t skip_destructor_rounds;
  33     uintptr_t size;  /* number of elements in the 'data' array */
  34     void* data[];
  35 } emutls_address_array;
  36
  37 static void emutls_shutdown(emutls_address_array *array);
  38
  39 #ifndef _WIN32
  40
  41 #include <pthread.h>
  42
  43 static pthread_mutex_t emutls_mutex = PTHREAD_MUTEX_INITIALIZER;
  44 static pthread_key_t emutls_pthread_key;
  45 static bool emutls_key_created = false;
  46
  47 typedef unsigned int gcc_word __attribute__((mode(word)));
  48 typedef unsigned int gcc_pointer __attribute__((mode(pointer)));
  49
  50 /* Default is not to use posix_memalign, so systems like Android
  51  * can use thread local data without heavier POSIX memory allocators.
  52  */
  53 #ifndef EMUTLS_USE_POSIX_MEMALIGN
  54 #define EMUTLS_USE_POSIX_MEMALIGN 0
  55 #endif
  56
  57 static __inline void *emutls_memalign_alloc(size_t align, size_t size) {
  58     void *base;
  59 #if EMUTLS_USE_POSIX_MEMALIGN
  60     if (posix_memalign(&base, align, size) != 0)
  61         abort();
  62 #else
  63     #define EXTRA_ALIGN_PTR_BYTES (align - 1 + sizeof(void*))
  64     char* object;
  65     if ((object = (char*)malloc(EXTRA_ALIGN_PTR_BYTES + size)) == NULL)
  66         abort();
  67     base = (void*)(((uintptr_t)(object + EXTRA_ALIGN_PTR_BYTES))
  68                     & ~(uintptr_t)(align - 1));
  69
  70     ((void**)base)[-1] = object;
  71 #endif
  72     return base;
  73 }
  74
  75 static __inline void emutls_memalign_free(void *base) {
  76 #if EMUTLS_USE_POSIX_MEMALIGN
  77     free(base);
  78 #else
  79     /* The mallocated address is in ((void**)base)[-1] */
  80     free(((void**)base)[-1]);
  81 #endif
  82 }
  83
  84 static __inline void emutls_setspecific(emutls_address_array *value) {
  85     pthread_setspecific(emutls_pthread_key, (void*) value);
  86 }
  87
  88 static __inline emutls_address_array* emutls_getspecific() {
  89     return (emutls_address_array*) pthread_getspecific(emutls_pthread_key);
  90 }
  91
  92 static void emutls_key_destructor(void* ptr) {
  93     emutls_address_array *array = (emutls_address_array*)ptr;
  94     if (array->skip_destructor_rounds > 0) {
  95         /* emutls is deallocated using a pthread key destructor. These
  96          * destructors are called in several rounds to accommodate destructor
  97          * functions that (re)initialize key values with pthread_setspecific.
  98          * Delay the emutls deallocation to accommodate other end-of-thread
  99          * cleanup tasks like calling thread_local destructors (e.g. the
 100          * __cxa_thread_atexit fallback in libc++abi).
 101          */
 102         array->skip_destructor_rounds--;
 103         emutls_setspecific(array);
 104     } else {
 105         emutls_shutdown(array);
 106         free(ptr);
 107     }
 108 }
 109
 110 static __inline void emutls_init(void) {
 111     if (pthread_key_create(&emutls_pthread_key, emutls_key_destructor) != 0)
 112         abort();
 113     emutls_key_created = true;
 114 }
 115
 116 static __inline void emutls_init_once(void) {
 117     static pthread_once_t once = PTHREAD_ONCE_INIT;
 118     pthread_once(&once, emutls_init);
 119 }
 120
 121 static __inline void emutls_lock() {
 122     pthread_mutex_lock(&emutls_mutex);
 123 }
 124
 125 static __inline void emutls_unlock() {
 126     pthread_mutex_unlock(&emutls_mutex);
 127 }
 128
 129 #else /* _WIN32 */
 130
 131 #include <windows.h>
 132 #include <malloc.h>
 133 #include <stdio.h>
 134 #include <assert.h>
 135
 136 static LPCRITICAL_SECTION emutls_mutex;
 137 static DWORD emutls_tls_index = TLS_OUT_OF_INDEXES;
 138
 139 typedef uintptr_t gcc_word;
 140 typedef void * gcc_pointer;
 141
 142 static void win_error(DWORD last_err, const char *hint) {
 143     char *buffer = NULL;
 144     if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
 145                        FORMAT_MESSAGE_FROM_SYSTEM |
 146                        FORMAT_MESSAGE_MAX_WIDTH_MASK,
 147                        NULL, last_err, 0, (LPSTR)&buffer, 1, NULL)) {
 148         fprintf(stderr, "Windows error: %s\n", buffer);
 149     } else {
 150         fprintf(stderr, "Unkown Windows error: %s\n", hint);
 151     }
 152     LocalFree(buffer);
 153 }
 154
 155 static __inline void win_abort(DWORD last_err, const char *hint) {
 156     win_error(last_err, hint);
 157     abort();
 158 }
 159
 160 static __inline void *emutls_memalign_alloc(size_t align, size_t size) {
 161     void *base = _aligned_malloc(size, align);
 162     if (!base)
 163         win_abort(GetLastError(), "_aligned_malloc");
 164     return base;
 165 }
 166
 167 static __inline void emutls_memalign_free(void *base) {
 168     _aligned_free(base);
 169 }
 170
 171 static void emutls_exit(void) {
 172     if (emutls_mutex) {
 173         DeleteCriticalSection(emutls_mutex);
 174         _aligned_free(emutls_mutex);
 175         emutls_mutex = NULL;
 176     }
 177     if (emutls_tls_index != TLS_OUT_OF_INDEXES) {
 178         emutls_shutdown((emutls_address_array*)TlsGetValue(emutls_tls_index));
 179         TlsFree(emutls_tls_index);
 180         emutls_tls_index = TLS_OUT_OF_INDEXES;
 181     }
 182 }
 183
 184 #pragma warning (push)
 185 #pragma warning (disable : 4100)
 186 static BOOL CALLBACK emutls_init(PINIT_ONCE p0, PVOID p1, PVOID *p2) {
 187     emutls_mutex = (LPCRITICAL_SECTION)_aligned_malloc(sizeof(CRITICAL_SECTION), 16);
 188     if (!emutls_mutex) {
 189         win_error(GetLastError(), "_aligned_malloc");
 190         return FALSE;
 191     }
 192     InitializeCriticalSection(emutls_mutex);
 193
 194     emutls_tls_index = TlsAlloc();
 195     if (emutls_tls_index == TLS_OUT_OF_INDEXES) {
 196         emutls_exit();
 197         win_error(GetLastError(), "TlsAlloc");
 198         return FALSE;
 199     }
 200     atexit(&emutls_exit);
 201     return TRUE;
 202 }
 203
 204 static __inline void emutls_init_once(void) {
 205     static INIT_ONCE once;
 206     InitOnceExecuteOnce(&once, emutls_init, NULL, NULL);
 207 }
 208
 209 static __inline void emutls_lock() {
 210     EnterCriticalSection(emutls_mutex);
 211 }
 212
 213 static __inline void emutls_unlock() {
 214     LeaveCriticalSection(emutls_mutex);
 215 }
 216
 217 static __inline void emutls_setspecific(emutls_address_array *value) {
 218     if (TlsSetValue(emutls_tls_index, (LPVOID) value) == 0)
 219         win_abort(GetLastError(), "TlsSetValue");
 220 }
 221
 222 static __inline emutls_address_array* emutls_getspecific() {
 223     LPVOID value = TlsGetValue(emutls_tls_index);
 224     if (value == NULL) {
 225         const DWORD err = GetLastError();
 226         if (err != ERROR_SUCCESS)
 227             win_abort(err, "TlsGetValue");
 228     }
 229     return (emutls_address_array*) value;
 230 }
 231
 232 /* Provide atomic load/store functions for emutls_get_index if built with MSVC.
 233  */
 234 #if !defined(__ATOMIC_RELEASE)
 235 #include <intrin.h>
 236
 237 enum { __ATOMIC_ACQUIRE = 2, __ATOMIC_RELEASE = 3 };
 238
 239 static __inline uintptr_t __atomic_load_n(void *ptr, unsigned type) {
 240     assert(type == __ATOMIC_ACQUIRE);
 241     // These return the previous value - but since we do an OR with 0,
 242     // it's equivalent to a plain load.
 243 #ifdef _WIN64
 244     return InterlockedOr64(ptr, 0);
 245 #else
 246     return InterlockedOr(ptr, 0);
 247 #endif
 248 }
 249
 250 static __inline void __atomic_store_n(void *ptr, uintptr_t val, unsigned type) {
 251     assert(type == __ATOMIC_RELEASE);
 252     InterlockedExchangePointer((void *volatile *)ptr, (void *)val);
 253 }
 254
 255 #endif /* __ATOMIC_RELEASE */
 256
 257 #pragma warning (pop)
 258
 259 #endif /* _WIN32 */
 260
 261 static size_t emutls_num_object = 0;  /* number of allocated TLS objects */
 262
 263 /* Free the allocated TLS data
 264  */
 265 static void emutls_shutdown(emutls_address_array *array) {
 266     if (array) {
 267         uintptr_t i;
 268         for (i = 0; i < array->size; ++i) {
 269             if (array->data[i])
 270                 emutls_memalign_free(array->data[i]);
 271         }
 272     }
 273 }
 274
 275 /* For every TLS variable xyz,
 276  * there is one __emutls_control variable named __emutls_v.xyz.
 277  * If xyz has non-zero initial value, __emutls_v.xyz's "value"
 278  * will point to __emutls_t.xyz, which has the initial value.
 279  */
 280 typedef struct __emutls_control {
 281     /* Must use gcc_word here, instead of size_t, to match GCC.  When
 282        gcc_word is larger than size_t, the upper extra bits are all
 283        zeros.  We can use variables of size_t to operate on size and
 284        align.  */
 285     gcc_word size;  /* size of the object in bytes */
 286     gcc_word align;  /* alignment of the object in bytes */
 287     union {
 288         uintptr_t index;  /* data[index-1] is the object address */
 289         void* address;  /* object address, when in single thread env */
 290     } object;
 291     void* value;  /* null or non-zero initial value for the object */
 292 } __emutls_control;
 293
 294 /* Emulated TLS objects are always allocated at run-time. */
 295 static __inline void *emutls_allocate_object(__emutls_control *control) {
 296     /* Use standard C types, check with gcc's emutls.o. */
 297     COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(gcc_pointer));
 298     COMPILE_TIME_ASSERT(sizeof(uintptr_t) == sizeof(void*));
 299
 300     size_t size = control->size;
 301     size_t align = control->align;
 302     void* base;
 303     if (align < sizeof(void*))
 304         align = sizeof(void*);
 305     /* Make sure that align is power of 2. */
 306     if ((align & (align - 1)) != 0)
 307         abort();
 308
 309     base = emutls_memalign_alloc(align, size);
 310     if (control->value)
 311         memcpy(base, control->value, size);
 312     else
 313         memset(base, 0, size);
 314     return base;
 315 }
 316
 317
 318 /* Returns control->object.index; set index if not allocated yet. */
 319 static __inline uintptr_t emutls_get_index(__emutls_control *control) {
 320     uintptr_t index = __atomic_load_n(&control->object.index, __ATOMIC_ACQUIRE);
 321     if (!index) {
 322         emutls_init_once();
 323         emutls_lock();
 324         index = control->object.index;
 325         if (!index) {
 326             index = ++emutls_num_object;
 327             __atomic_store_n(&control->object.index, index, __ATOMIC_RELEASE);
 328         }
 329         emutls_unlock();
 330     }
 331     return index;
 332 }
 333
 334 /* Updates newly allocated thread local emutls_address_array. */
 335 static __inline void emutls_check_array_set_size(emutls_address_array *array,
 336                                                  uintptr_t size) {
 337     if (array == NULL)
 338         abort();
 339     array->size = size;
 340     emutls_setspecific(array);
 341 }
 342
 343 /* Returns the new 'data' array size, number of elements,
 344  * which must be no smaller than the given index.
 345  */
 346 static __inline uintptr_t emutls_new_data_array_size(uintptr_t index) {
 347    /* Need to allocate emutls_address_array with extra slots
 348     * to store the header.
 349     * Round up the emutls_address_array size to multiple of 16.
 350     */
 351     uintptr_t header_words = sizeof(emutls_address_array) / sizeof(void *);
 352     return ((index + header_words + 15) & ~((uintptr_t)15)) - header_words;
 353 }
 354
 355 /* Returns the size in bytes required for an emutls_address_array with
 356  * N number of elements for data field.
 357  */
 358 static __inline uintptr_t emutls_asize(uintptr_t N) {
 359     return N * sizeof(void *) + sizeof(emutls_address_array);
 360 }
 361
 362 /* Returns the thread local emutls_address_array.
 363  * Extends its size if necessary to hold address at index.
 364  */
 365 static __inline emutls_address_array *
 366 emutls_get_address_array(uintptr_t index) {
 367     emutls_address_array* array = emutls_getspecific();
 368     if (array == NULL) {
 369         uintptr_t new_size = emutls_new_data_array_size(index);
 370         array = (emutls_address_array*) malloc(emutls_asize(new_size));
 371         if (array) {
 372             memset(array->data, 0, new_size * sizeof(void*));
 373             array->skip_destructor_rounds = EMUTLS_SKIP_DESTRUCTOR_ROUNDS;
 374         }
 375         emutls_check_array_set_size(array, new_size);
 376     } else if (index > array->size) {
 377         uintptr_t orig_size = array->size;
 378         uintptr_t new_size = emutls_new_data_array_size(index);
 379         array = (emutls_address_array*) realloc(array, emutls_asize(new_size));
 380         if (array)
 381             memset(array->data + orig_size, 0,
 382                    (new_size - orig_size) * sizeof(void*));
 383         emutls_check_array_set_size(array, new_size);
 384     }
 385     return array;
 386 }
 387
 388 void* __emutls_get_address(__emutls_control* control) {
 389     uintptr_t index = emutls_get_index(control);
 390     emutls_address_array* array = emutls_get_address_array(index--);
 391     if (array->data[index] == NULL)
 392         array->data[index] = emutls_allocate_object(control);
 393     return array->data[index];
 394 }
 395
 396 #ifdef __BIONIC__
 397 /* Called by Bionic on dlclose to delete the emutls pthread key. */
 398 __attribute__((visibility("hidden")))
 399 void __emutls_unregister_key(void) {
 400     if (emutls_key_created) {
 401         pthread_key_delete(emutls_pthread_key);
 402         emutls_key_created = false;
 403     }
 404 }
 405 #endif