/* TLS emulation.
  Copyright (C) 2006-2024 Free Software Foundation, Inc.
  Contributed by Jakub Jelinek <[email protected]>.

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 "tconfig.h"
#include "tsystem.h"
#include "coretypes.h"
#include "tm.h"
#include "libgcc_tm.h"
#include "gthr.h"

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[];
};

/* EMUTLS_ATTR is provided to allow targets to build the emulated tls
  routines as weak definitions, for example.
  If there is no definition, fall back to the default.  */
#ifndef EMUTLS_ATTR
#  define EMUTLS_ATTR
#endif

/* __emutls_get_address and __emutls_register_common are registered as
  builtins, but the compiler struct __emutls_object doesn't have
  a union in there and is only created when actually needed for
  the calls to the builtins, so the builtins are created with void *
  arguments rather than struct __emutls_object *.  Avoid
  -Wbuiltin-declaration-mismatch warnings.  */
#pragma GCC diagnostic ignored "-Wbuiltin-declaration-mismatch"

EMUTLS_ATTR
void *__emutls_get_address (void *);
EMUTLS_ATTR
void __emutls_register_common (void *, word, word, void *);

#ifdef __GTHREADS
#ifdef __GTHREAD_MUTEX_INIT
static __gthread_mutex_t emutls_mutex = __GTHREAD_MUTEX_INIT;
#else
static __gthread_mutex_t emutls_mutex;
#endif
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)
{
#ifndef __GTHREAD_MUTEX_INIT
 __GTHREAD_MUTEX_INIT_FUNCTION (&emutls_mutex);
#endif
 if (__gthread_key_create (&emutls_key, emutls_destroy) != 0)
   abort ();
}
#endif

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;
}

/* Despite applying the attribute to the declaration, in this case the mis-
  match between the builtin's declaration [void * (*)(void *)] and the
  implementation here, causes the decl. attributes to be discarded.  */

EMUTLS_ATTR void *
__emutls_get_address (void *vobj)
{
 struct __emutls_object *obj = vobj;

 if (! __gthread_active_p ())
   {
     if (__builtin_expect (obj->loc.ptr == NULL, 0))
       obj->loc.ptr = emutls_alloc (obj);
     return obj->loc.ptr;
   }

#ifndef __GTHREADS
 abort ();
#else
 pointer offset = __atomic_load_n (&obj->loc.offset, __ATOMIC_ACQUIRE);

 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;
         __atomic_store_n (&obj->loc.offset, offset, __ATOMIC_RELEASE);
       }
     __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;
#endif
}

EMUTLS_ATTR void
__emutls_register_common (void *vobj,
                         word size, word align, void *templ)
{
 struct __emutls_object *obj = vobj;

 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;
}