| 0,0 → 1,218 |
|---|
| /* TLS emulation. |
| Copyright (C) 2006, 2008, 2009 Free Software Foundation, Inc. |
| Contributed by Jakub Jelinek <jakub@redhat.com>. |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| Under Section 7 of GPL version 3, you are granted additional |
| permissions described in the GCC Runtime Library Exception, version |
| 3.1, as published by the Free Software Foundation. |
| |
| You should have received a copy of the GNU General Public License and |
| a copy of the GCC Runtime Library Exception along with this program; |
| see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| |
| #include <stdlib.h> |
| #include <malloc.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <gthr.h> |
| |
| void *tls_alloc(void); |
| void __mutex_lock(volatile int *val); |
| |
| |
| static inline void yield(void) |
| { |
| __asm__ __volatile__( |
| "int $0x40" |
| ::"a"(68), "b"(1)); |
| }; |
| |
| int __gthread_once (__gthread_once_t *once, void (*func) (void)) |
| { |
| if (once == NULL || func == NULL) |
| return EINVAL; |
| |
| if (! once->done) |
| { |
| if(++once->started == 0) |
| { |
| (*func) (); |
| once->done = 1; |
| } |
| else |
| { |
| /* Another thread is currently executing the code, so wait for it |
| to finish; yield the CPU in the meantime. If performance |
| does become an issue, the solution is to use an Event that |
| we wait on here (and set above), but that implies a place to |
| create the event before this routine is called. */ |
| while (! once->done) |
| yield(); |
| } |
| } |
| return 0; |
| } |
| |
| |
| #define __GTHREAD_ONCE_INIT {0, -1} |
| |
| typedef unsigned int word __attribute__((mode(word))); |
| typedef unsigned int pointer __attribute__((mode(pointer))); |
| |
| struct __emutls_object |
| { |
| word size; |
| word align; |
| union { |
| pointer offset; |
| void *ptr; |
| } loc; |
| void *templ; |
| }; |
| |
| struct __emutls_array |
| { |
| pointer size; |
| void **data[]; |
| }; |
| |
| void *__emutls_get_address (struct __emutls_object *); |
| void __emutls_register_common (struct __emutls_object *, word, word, void *); |
| |
| static __gthread_mutex_t emutls_mutex; |
| static __gthread_key_t emutls_key; |
| static pointer emutls_size; |
| |
| static void emutls_destroy (void *ptr) |
| { |
| struct __emutls_array *arr = ptr; |
| pointer size = arr->size; |
| pointer i; |
| |
| for (i = 0; i < size; ++i) |
| { |
| if (arr->data[i]) |
| free (arr->data[i][-1]); |
| } |
| free (ptr); |
| }; |
| |
| static void emutls_init (void) |
| { |
| if (__gthread_key_create (&emutls_key, emutls_destroy) != 0) |
| abort (); |
| } |
| |
| static void *emutls_alloc (struct __emutls_object *obj) |
| { |
| void *ptr; |
| void *ret; |
| |
| /* We could use here posix_memalign if available and adjust |
| emutls_destroy accordingly. */ |
| if (obj->align <= sizeof (void *)) |
| { |
| ptr = malloc (obj->size + sizeof (void *)); |
| if (ptr == NULL) |
| abort (); |
| ((void **) ptr)[0] = ptr; |
| ret = ptr + sizeof (void *); |
| } |
| else |
| { |
| ptr = malloc (obj->size + sizeof (void *) + obj->align - 1); |
| if (ptr == NULL) |
| abort (); |
| ret = (void *) (((pointer) (ptr + sizeof (void *) + obj->align - 1)) |
| & ~(pointer)(obj->align - 1)); |
| ((void **) ret)[-1] = ptr; |
| } |
| |
| if (obj->templ) |
| memcpy (ret, obj->templ, obj->size); |
| else |
| memset (ret, 0, obj->size); |
| |
| return ret; |
| } |
| |
| void * __emutls_get_address (struct __emutls_object *obj) |
| { |
| pointer offset = obj->loc.offset; |
| |
| if (__builtin_expect (offset == 0, 0)) |
| { |
| static __gthread_once_t once = __GTHREAD_ONCE_INIT; |
| __gthread_once (&once, emutls_init); |
| __gthread_mutex_lock (&emutls_mutex); |
| offset = obj->loc.offset; |
| if (offset == 0) |
| { |
| offset = ++emutls_size; |
| obj->loc.offset = offset; |
| } |
| __gthread_mutex_unlock (&emutls_mutex); |
| } |
| |
| struct __emutls_array *arr = __gthread_getspecific (emutls_key); |
| if (__builtin_expect (arr == NULL, 0)) |
| { |
| pointer size = offset + 32; |
| arr = calloc (size + 1, sizeof (void *)); |
| if (arr == NULL) |
| abort (); |
| arr->size = size; |
| __gthread_setspecific (emutls_key, (void *) arr); |
| } |
| else if (__builtin_expect (offset > arr->size, 0)) |
| { |
| pointer orig_size = arr->size; |
| pointer size = orig_size * 2; |
| if (offset > size) |
| size = offset + 32; |
| arr = realloc (arr, (size + 1) * sizeof (void *)); |
| if (arr == NULL) |
| abort (); |
| arr->size = size; |
| memset (arr->data + orig_size, 0, |
| (size - orig_size) * sizeof (void *)); |
| __gthread_setspecific (emutls_key, (void *) arr); |
| } |
| |
| void *ret = arr->data[offset - 1]; |
| if (__builtin_expect (ret == NULL, 0)) |
| { |
| ret = emutls_alloc (obj); |
| arr->data[offset - 1] = ret; |
| } |
| return ret; |
| } |
| |
| |
| void __emutls_register_common (struct __emutls_object *obj, |
| word size, word align, void *templ) |
| { |
| if (obj->size < size) |
| { |
| obj->size = size; |
| obj->templ = NULL; |
| } |
| if (obj->align < align) |
| obj->align = align; |
| if (templ && size == obj->size) |
| obj->templ = templ; |
| } |