gcc/emutls.c

   1 /* TLS emulation.
   2    Copyright (C) 2006, 2008, 2009 Free Software Foundation, Inc.
   3    Contributed by Jakub Jelinek <jakub@redhat.com>.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 Under Section 7 of GPL version 3, you are granted additional
  18 permissions described in the GCC Runtime Library Exception, version
  19 3.1, as published by the Free Software Foundation.
  20
  21 You should have received a copy of the GNU General Public License and
  22 a copy of the GCC Runtime Library Exception along with this program;
  23 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26 #include "tconfig.h"
  27 #include "tsystem.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "gthr.h"
  31
  32 typedef unsigned int word __attribute__((mode(word)));
  33 typedef unsigned int pointer __attribute__((mode(pointer)));
  34
  35 struct __emutls_object
  36 {
  37   word size;
  38   word align;
  39   union {
  40     pointer offset;
  41     void *ptr;
  42   } loc;
  43   void *templ;
  44 };
  45
  46 struct __emutls_array
  47 {
  48   pointer size;
  49   void **data[];
  50 };
  51
  52 void *__emutls_get_address (struct __emutls_object *);
  53 void __emutls_register_common (struct __emutls_object *, word, word, void *);
  54
  55 #ifdef __GTHREADS
  56 #ifdef __GTHREAD_MUTEX_INIT
  57 static __gthread_mutex_t emutls_mutex = __GTHREAD_MUTEX_INIT;
  58 #else
  59 static __gthread_mutex_t emutls_mutex;
  60 #endif
  61 static __gthread_key_t emutls_key;
  62 static pointer emutls_size;
  63
  64 static void
  65 emutls_destroy (void *ptr)
  66 {
  67   struct __emutls_array *arr = ptr;
  68   pointer size = arr->size;
  69   pointer i;
  70
  71   for (i = 0; i < size; ++i)
  72     {
  73       if (arr->data[i])
  74         free (arr->data[i][-1]);
  75     }
  76
  77   free (ptr);
  78 }
  79
  80 static void
  81 emutls_init (void)
  82 {
  83 #ifndef __GTHREAD_MUTEX_INIT
  84   __GTHREAD_MUTEX_INIT_FUNCTION (&emutls_mutex);
  85 #endif
  86   if (__gthread_key_create (&emutls_key, emutls_destroy) != 0)
  87     abort ();
  88 }
  89 #endif
  90
  91 static void *
  92 emutls_alloc (struct __emutls_object *obj)
  93 {
  94   void *ptr;
  95   void *ret;
  96
  97   /* We could use here posix_memalign if available and adjust
  98      emutls_destroy accordingly.  */
  99   if (obj->align <= sizeof (void *))
 100     {
 101       ptr = malloc (obj->size + sizeof (void *));
 102       if (ptr == NULL)
 103         abort ();
 104       ((void **) ptr)[0] = ptr;
 105       ret = ptr + sizeof (void *);
 106     }
 107   else
 108     {
 109       ptr = malloc (obj->size + sizeof (void *) + obj->align - 1);
 110       if (ptr == NULL)
 111         abort ();
 112       ret = (void *) (((pointer) (ptr + sizeof (void *) + obj->align - 1))
 113                       & ~(pointer)(obj->align - 1));
 114       ((void **) ret)[-1] = ptr;
 115     }
 116
 117   if (obj->templ)
 118     memcpy (ret, obj->templ, obj->size);
 119   else
 120     memset (ret, 0, obj->size);
 121
 122   return ret;
 123 }
 124
 125 void *
 126 __emutls_get_address (struct __emutls_object *obj)
 127 {
 128   if (! __gthread_active_p ())
 129     {
 130       if (__builtin_expect (obj->loc.ptr == NULL, 0))
 131         obj->loc.ptr = emutls_alloc (obj);
 132       return obj->loc.ptr;
 133     }
 134
 135 #ifndef __GTHREADS
 136   abort ();
 137 #else
 138   pointer offset = obj->loc.offset;
 139
 140   if (__builtin_expect (offset == 0, 0))
 141     {
 142       static __gthread_once_t once = __GTHREAD_ONCE_INIT;
 143       __gthread_once (&once, emutls_init);
 144       __gthread_mutex_lock (&emutls_mutex);
 145       offset = obj->loc.offset;
 146       if (offset == 0)
 147         {
 148           offset = ++emutls_size;
 149           obj->loc.offset = offset;
 150         }
 151       __gthread_mutex_unlock (&emutls_mutex);
 152     }
 153
 154   /* Do not allow emutls_key to be loaded before offset.  */
 155   __sync_synchronize();
 156
 157   struct __emutls_array *arr = __gthread_getspecific (emutls_key);
 158   if (__builtin_expect (arr == NULL, 0))
 159     {
 160       pointer size = offset + 32;
 161       arr = calloc (size + 1, sizeof (void *));
 162       if (arr == NULL)
 163         abort ();
 164       arr->size = size;
 165       __gthread_setspecific (emutls_key, (void *) arr);
 166     }
 167   else if (__builtin_expect (offset > arr->size, 0))
 168     {
 169       pointer orig_size = arr->size;
 170       pointer size = orig_size * 2;
 171       if (offset > size)
 172         size = offset + 32;
 173       arr = realloc (arr, (size + 1) * sizeof (void *));
 174       if (arr == NULL)
 175         abort ();
 176       arr->size = size;
 177       memset (arr->data + orig_size, 0,
 178               (size - orig_size) * sizeof (void *));
 179       __gthread_setspecific (emutls_key, (void *) arr);
 180     }
 181
 182   void *ret = arr->data[offset - 1];
 183   if (__builtin_expect (ret == NULL, 0))
 184     {
 185       ret = emutls_alloc (obj);
 186       arr->data[offset - 1] = ret;
 187     }
 188   return ret;
 189 #endif
 190 }
 191
 192 void
 193 __emutls_register_common (struct __emutls_object *obj,
 194                           word size, word align, void *templ)
 195 {
 196   if (obj->size < size)
 197     {
 198       obj->size = size;
 199       obj->templ = NULL;
 200     }
 201   if (obj->align < align)
 202     obj->align = align;
 203   if (templ && size == obj->size)
 204     obj->templ = templ;
 205 }