Subversion Repositories openrisc

/* Thread library support for -fsplit-stack.  */
/* Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
   Contributed by Ian Lance Taylor <iant@google.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 "tconfig.h"
#include "tsystem.h"
#include "coretypes.h"
#include "tm.h"
#include "libgcc_tm.h"
 
/* If inhibit_libc is defined, we can not compile this file.  The
   effect is that people will not be able to use -fsplit-stack.  That
   is much better than failing the build particularly since people
   will want to define inhibit_libc while building a compiler which
   can build glibc.  */
 
#ifndef inhibit_libc
 
#include <errno.h>
#include <pthread.h>
 
#include "generic-morestack.h"
 
/* We declare the pthread functions we need as weak, so that
   libgcc_s.so does not need to be linked against -lpthread.  */
 
extern int pthread_once (pthread_once_t *, void (*) (void))
  __attribute__ ((weak));
 
extern int pthread_key_create (pthread_key_t *, void (*) (void *))
  __attribute__ ((weak));
 
extern int pthread_setspecific (pthread_key_t, const void *)
  __attribute__ ((weak));
 
/* The key for the list of stack segments to free when the thread
   exits.  This is created by pthread_key_create.  */
 
static pthread_key_t segment_list_key;
 
/* Used to only run create_key once.  */
 
static pthread_once_t create_key_once = PTHREAD_ONCE_INIT;
 
/* Release all the segments for a thread.  This is the destructor
   function used by pthread_key_create, and is called when a thread
   exits.  */
 
static void
free_segments (void* arg)
{
  __morestack_release_segments ((struct stack_segment **) arg, 1);
}
 
/* Set up the key for the list of segments.  This is called via
   pthread_once.  */
 
static void
create_key (void)
{
  int err;
 
  err = pthread_key_create (&segment_list_key, free_segments);
  if (err != 0)
    {
      static const char msg[] = "pthread_key_create failed: errno ";
      __morestack_fail (msg, sizeof msg - 1, err);
    }
}
 
/* Pass information from the pthread_create wrapper to
   stack_split_initialize_thread.  */
 
struct pthread_create_args
{
  void *(*start_routine) (void *);
  void *arg;
};
 
/* Initialize a thread.  This is called via pthread_create.  It calls
   a target dependent function to set up any required stack guard.  */
 
static void* stack_split_initialize_thread (void *)
  __attribute__ ((no_split_stack));
 
static void *
stack_split_initialize_thread (void *varg)
{
  struct pthread_create_args *args = (struct pthread_create_args *) varg;
  int err;
  void *(*start_routine) (void *);
  void *arg;
 
  __stack_split_initialize ();
 
  err = pthread_setspecific (segment_list_key, (void *) &__morestack_segments);
  if (err != 0)
    {
      static const char msg[] = "pthread_setspecific failed: errno ";
      __morestack_fail (msg, sizeof msg - 1, err);
    }
 
  start_routine = args->start_routine;
  arg = args->arg;
  free (args);
  return (*start_routine) (arg);
}
 
/* This function wraps calls to pthread_create to make sure that the
   stack guard is initialized for new threads.  FIXME: This hack will
   not be necessary if glibc supports -fsplit-stack directly.  */
 
int __wrap_pthread_create (pthread_t *, const pthread_attr_t *,
			   void *(*start_routine) (void *), void *)
  __attribute__ ((visibility ("hidden")));
 
extern int __real_pthread_create (pthread_t *, const pthread_attr_t *,
				  void *(*start_routine) (void *), void *)
  __attribute__ ((weak));
 
int
__wrap_pthread_create (pthread_t *tid, const pthread_attr_t *attr,
		       void *(*start_routine) (void *), void *arg)
{
  int err;
  struct pthread_create_args* args;
 
  err = pthread_once (&create_key_once, create_key);
  if (err != 0)
    {
      static const char msg[] = "pthread_once failed: errno ";
      __morestack_fail (msg, sizeof msg - 1, err);
    }
 
  args = malloc (sizeof (struct pthread_create_args));
  if (args == NULL)
    return EAGAIN;
  args->start_routine = start_routine;
  args->arg = arg;
  return __real_pthread_create (tid, attr, stack_split_initialize_thread, args);
}
 
#endif /* !defined (inhibit_libc) */