Subversion Repositories openrisc

/* 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 <assert.h>

#include <errno.h>

#include <signal.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/mman.h>

#include <sys/uio.h>

#include "generic-morestack.h"

typedef unsigned uintptr_type __attribute__ ((mode (pointer)));

/* This file contains subroutines that are used by code compiled with

   -fsplit-stack.  */

/* Declare functions to avoid warnings--there is no header file for

   these internal functions.  We give most of these functions the

   flatten attribute in order to minimize their stack usage--here we

   must minimize stack usage even at the cost of code size, and in

   general inlining everything will do that.  */

extern void

__generic_morestack_set_initial_sp (void *sp, size_t len)

  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));

extern void *

__generic_morestack (size_t *frame_size, void *old_stack, size_t param_size)

  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));

extern void *

__generic_releasestack (size_t *pavailable)

  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));

extern void

__morestack_block_signals (void)

  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));

extern void

__morestack_unblock_signals (void)

  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));

extern size_t

__generic_findstack (void *stack)

  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));

extern void

__morestack_load_mmap (void)

  __attribute__ ((no_split_stack, visibility ("hidden")));

extern void *

__morestack_allocate_stack_space (size_t size)

  __attribute__ ((visibility ("hidden")));

/* These are functions which -fsplit-stack code can call.  These are

   not called by the compiler, and are not hidden.  FIXME: These

   should be in some header file somewhere, somehow.  */

extern void *

__splitstack_find (void *, void *, size_t *, void **, void **, void **)

  __attribute__ ((visibility ("default")));

extern void

__splitstack_block_signals (int *, int *)

  __attribute__ ((visibility ("default")));

extern void

__splitstack_getcontext (void *context[10])

  __attribute__ ((no_split_stack, visibility ("default")));

extern void

__splitstack_setcontext (void *context[10])

  __attribute__ ((no_split_stack, visibility ("default")));

extern void *

__splitstack_makecontext (size_t, void *context[10], size_t *)

  __attribute__ ((visibility ("default")));

extern void *

__splitstack_resetcontext (void *context[10], size_t *)

  __attribute__ ((visibility ("default")));

extern void

__splitstack_releasecontext (void *context[10])

  __attribute__ ((visibility ("default")));

extern void

__splitstack_block_signals_context (void *context[10], int *, int *)

  __attribute__ ((visibility ("default")));

extern void *

__splitstack_find_context (void *context[10], size_t *, void **, void **,

                           void **)

  __attribute__ ((visibility ("default")));

/* These functions must be defined by the processor specific code.  */

extern void *__morestack_get_guard (void)

  __attribute__ ((no_split_stack, visibility ("hidden")));

extern void __morestack_set_guard (void *)

  __attribute__ ((no_split_stack, visibility ("hidden")));

extern void *__morestack_make_guard (void *, size_t)

  __attribute__ ((no_split_stack, visibility ("hidden")));

/* When we allocate a stack segment we put this header at the

   start.  */

struct stack_segment

{

  /* The previous stack segment--when a function running on this stack

     segment returns, it will run on the previous one.  */

  struct stack_segment *prev;

  /* The next stack segment, if it has been allocated--when a function

     is running on this stack segment, the next one is not being

     used.  */

  struct stack_segment *next;

  /* The total size of this stack segment.  */

  size_t size;

  /* The stack address when this stack was created.  This is used when

     popping the stack.  */

  void *old_stack;

  /* A list of memory blocks allocated by dynamic stack

     allocation.  */

  struct dynamic_allocation_blocks *dynamic_allocation;

  /* A list of dynamic memory blocks no longer needed.  */

  struct dynamic_allocation_blocks *free_dynamic_allocation;

  /* An extra pointer in case we need some more information some

     day.  */

  void *extra;

};

/* This structure holds the (approximate) initial stack pointer and

   size for the system supplied stack for a thread.  This is set when

   the thread is created.  We also store a sigset_t here to hold the

   signal mask while splitting the stack, since we don't want to store

   that on the stack.  */

struct initial_sp

{

  /* The initial stack pointer.  */

  void *sp;

  /* The stack length.  */

  size_t len;

  /* A signal mask, put here so that the thread can use it without

     needing stack space.  */

  sigset_t mask;

  /* Non-zero if we should not block signals.  This is a reversed flag

     so that the default zero value is the safe value.  The type is

     uintptr_type because it replaced one of the void * pointers in

     extra.  */

  uintptr_type dont_block_signals;

  /* Some extra space for later extensibility.  */

  void *extra[4];

};

/* A list of memory blocks allocated by dynamic stack allocation.

   This is used for code that calls alloca or uses variably sized

   arrays.  */

struct dynamic_allocation_blocks

{

  /* The next block in the list.  */

  struct dynamic_allocation_blocks *next;

  /* The size of the allocated memory.  */

  size_t size;

  /* The allocated memory.  */

  void *block;

};

/* These thread local global variables must be shared by all split

   stack code across shared library boundaries.  Therefore, they have

   default visibility.  They have extensibility fields if needed for

   new versions.  If more radical changes are needed, new code can be

   written using new variable names, while still using the existing

   variables in a backward compatible manner.  Symbol versioning is

   also used, although, since these variables are only referenced by

   code in this file and generic-morestack-thread.c, it is likely that

   simply using new names will suffice.  */

/* The first stack segment allocated for this thread.  */

__thread struct stack_segment *__morestack_segments

  __attribute__ ((visibility ("default")));

/* The stack segment that we think we are currently using.  This will

   be correct in normal usage, but will be incorrect if an exception

   unwinds into a different stack segment or if longjmp jumps to a

   different stack segment.  */

__thread struct stack_segment *__morestack_current_segment

  __attribute__ ((visibility ("default")));

/* The initial stack pointer and size for this thread.  */

__thread struct initial_sp __morestack_initial_sp

  __attribute__ ((visibility ("default")));

/* A static signal mask, to avoid taking up stack space.  */

static sigset_t __morestack_fullmask;

/* Convert an integer to a decimal string without using much stack

   space.  Return a pointer to the part of the buffer to use.  We this

   instead of sprintf because sprintf will require too much stack

   space.  */

static char *

print_int (int val, char *buf, int buflen, size_t *print_len)

{

  int is_negative;

  int i;

  unsigned int uval;

  uval = (unsigned int) val;

  if (val >= 0)

    is_negative = 0;

  else

    {

      is_negative = 1;

      uval = - uval;

    }

  i = buflen;

  do

    {

      --i;

      buf[i] = '0' + (uval % 10);

      uval /= 10;

    }

  while (uval != 0 && i > 0);

  if (is_negative)

    {

      if (i > 0)

        --i;

      buf[i] = '-';

    }

  *print_len = buflen - i;

  return buf + i;

}

/* Print the string MSG/LEN, the errno number ERR, and a newline on

   stderr.  Then crash.  */

void

__morestack_fail (const char *, size_t, int) __attribute__ ((noreturn));

void

__morestack_fail (const char *msg, size_t len, int err)

{

  char buf[24];

  static const char nl[] = "\n";

  struct iovec iov[3];

  union { char *p; const char *cp; } const_cast;

  const_cast.cp = msg;

  iov[0].iov_base = const_cast.p;

  iov[0].iov_len = len;

  /* We can't call strerror, because it may try to translate the error

     message, and that would use too much stack space.  */

  iov[1].iov_base = print_int (err, buf, sizeof buf, &iov[1].iov_len);

  const_cast.cp = &nl[0];

  iov[2].iov_base = const_cast.p;

  iov[2].iov_len = sizeof nl - 1;

  /* FIXME: On systems without writev we need to issue three write

     calls, or punt on printing errno.  For now this is irrelevant

     since stack splitting only works on GNU/Linux anyhow.  */

  writev (2, iov, 3);

  abort ();

}

/* Allocate a new stack segment.  FRAME_SIZE is the required frame

   size.  */

static struct stack_segment *

allocate_segment (size_t frame_size)

{

  static unsigned int static_pagesize;

  static int use_guard_page;

  unsigned int pagesize;

  unsigned int overhead;

  unsigned int allocate;

  void *space;

  struct stack_segment *pss;

  pagesize = static_pagesize;

  if (pagesize == 0)

    {

      unsigned int p;

      pagesize = getpagesize ();

#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4

      p = __sync_val_compare_and_swap (&static_pagesize, 0, pagesize);

#else

      /* Just hope this assignment is atomic.  */

      static_pagesize = pagesize;

      p = 0;

#endif

      use_guard_page = getenv ("SPLIT_STACK_GUARD") != 0;

      /* FIXME: I'm not sure this assert should be in the released

         code.  */

      assert (p == 0 || p == pagesize);

    }

  overhead = sizeof (struct stack_segment);

  allocate = pagesize;

  if (allocate < MINSIGSTKSZ)

    allocate = ((MINSIGSTKSZ + overhead + pagesize - 1)

                & ~ (pagesize - 1));

  if (allocate < frame_size)

    allocate = ((frame_size + overhead + pagesize - 1)

                & ~ (pagesize - 1));

  if (use_guard_page)

    allocate += pagesize;

  /* FIXME: If this binary requires an executable stack, then we need

     to set PROT_EXEC.  Unfortunately figuring that out is complicated

     and target dependent.  We would need to use dl_iterate_phdr to

     see if there is any object which does not have a PT_GNU_STACK

     phdr, though only for architectures which use that mechanism.  */

  space = mmap (NULL, allocate, PROT_READ | PROT_WRITE,

                MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

  if (space == MAP_FAILED)

    {

      static const char msg[] =

        "unable to allocate additional stack space: errno ";

      __morestack_fail (msg, sizeof msg - 1, errno);

    }

  if (use_guard_page)

    {

      void *guard;

#ifdef STACK_GROWS_DOWNWARD

      guard = space;

      space = (char *) space + pagesize;

#else

      guard = space + allocate - pagesize;

#endif

      mprotect (guard, pagesize, PROT_NONE);

      allocate -= pagesize;

    }

  pss = (struct stack_segment *) space;

  pss->prev = NULL;

  pss->next = NULL;

  pss->size = allocate - overhead;

  pss->dynamic_allocation = NULL;

  pss->free_dynamic_allocation = NULL;

  pss->extra = NULL;

  return pss;

}

/* Free a list of dynamic blocks.  */

static void

free_dynamic_blocks (struct dynamic_allocation_blocks *p)

{

  while (p != NULL)

    {

      struct dynamic_allocation_blocks *next;

      next = p->next;

      free (p->block);

      free (p);

      p = next;

    }

}

/* Merge two lists of dynamic blocks.  */

static struct dynamic_allocation_blocks *

merge_dynamic_blocks (struct dynamic_allocation_blocks *a,

                      struct dynamic_allocation_blocks *b)

{

  struct dynamic_allocation_blocks **pp;

  if (a == NULL)

    return b;

  if (b == NULL)

    return a;

  for (pp = &a->next; *pp != NULL; pp = &(*pp)->next)

    ;

  *pp = b;

  return a;

}

/* Release stack segments.  If FREE_DYNAMIC is non-zero, we also free

   any dynamic blocks.  Otherwise we return them.  */

struct dynamic_allocation_blocks *

__morestack_release_segments (struct stack_segment **pp, int free_dynamic)

{

  struct dynamic_allocation_blocks *ret;

  struct stack_segment *pss;

  ret = NULL;

  pss = *pp;

  while (pss != NULL)

    {

      struct stack_segment *next;

      unsigned int allocate;

      next = pss->next;

      if (pss->dynamic_allocation != NULL

          || pss->free_dynamic_allocation != NULL)

        {

          if (free_dynamic)

            {

              free_dynamic_blocks (pss->dynamic_allocation);

              free_dynamic_blocks (pss->free_dynamic_allocation);

            }

          else

            {

              ret = merge_dynamic_blocks (pss->dynamic_allocation, ret);

              ret = merge_dynamic_blocks (pss->free_dynamic_allocation, ret);

            }

        }

      allocate = pss->size + sizeof (struct stack_segment);

      if (munmap (pss, allocate) < 0)

        {

          static const char msg[] = "munmap of stack space failed: errno ";

          __morestack_fail (msg, sizeof msg - 1, errno);

        }

      pss = next;

    }

  *pp = NULL;

  return ret;

}

/* This function is called by a processor specific function to set the

   initial stack pointer for a thread.  The operating system will

   always create a stack for a thread.  Here we record a stack pointer

   near the base of that stack.  The size argument lets the processor

   specific code estimate how much stack space is available on this

   initial stack.  */

void

__generic_morestack_set_initial_sp (void *sp, size_t len)

{

  /* The stack pointer most likely starts on a page boundary.  Adjust

     to the nearest 512 byte boundary.  It's not essential that we be

     precise here; getting it wrong will just leave some stack space

     unused.  */

#ifdef STACK_GROWS_DOWNWARD

  sp = (void *) ((((__UINTPTR_TYPE__) sp + 511U) / 512U) * 512U);

#else

  sp = (void *) ((((__UINTPTR_TYPE__) sp - 511U) / 512U) * 512U);

#endif

  __morestack_initial_sp.sp = sp;

  __morestack_initial_sp.len = len;

  sigemptyset (&__morestack_initial_sp.mask);

  sigfillset (&__morestack_fullmask);

#if defined(__GLIBC__) && defined(__linux__)

  /* In glibc, the first two real time signals are used by the NPTL

     threading library.  By taking them out of the set of signals, we

     avoiding copying the signal mask in pthread_sigmask.  More

     importantly, pthread_sigmask uses less stack space on x86_64.  */

  sigdelset (&__morestack_fullmask, __SIGRTMIN);

  sigdelset (&__morestack_fullmask, __SIGRTMIN + 1);

#endif

}

/* This function is called by a processor specific function which is

   run in the prologue when more stack is needed.  The processor

   specific function handles the details of saving registers and

   frobbing the actual stack pointer.  This function is responsible

   for allocating a new stack segment and for copying a parameter

   block from the old stack to the new one.  On function entry

   *PFRAME_SIZE is the size of the required stack frame--the returned

   stack must be at least this large.  On function exit *PFRAME_SIZE

   is the amount of space remaining on the allocated stack.  OLD_STACK

   points at the parameters the old stack (really the current one

   while this function is running).  OLD_STACK is saved so that it can

   be returned by a later call to __generic_releasestack.  PARAM_SIZE

   is the size in bytes of parameters to copy to the new stack.  This

   function returns a pointer to the new stack segment, pointing to

   the memory after the parameters have been copied.  The returned

   value minus the returned *PFRAME_SIZE (or plus if the stack grows

   upward) is the first address on the stack which should not be used.

   This function is running on the old stack and has only a limited

   amount of stack space available.  */

void *

__generic_morestack (size_t *pframe_size, void *old_stack, size_t param_size)

{

  size_t frame_size = *pframe_size;

  struct stack_segment *current;

  struct stack_segment **pp;

  struct dynamic_allocation_blocks *dynamic;

  char *from;

  char *to;

  void *ret;

  size_t i;

  current = __morestack_current_segment;

  pp = current != NULL ? &current->next : &__morestack_segments;

  if (*pp != NULL && (*pp)->size < frame_size)

    dynamic = __morestack_release_segments (pp, 0);

  else

    dynamic = NULL;

  current = *pp;

  if (current == NULL)

    {

      current = allocate_segment (frame_size + param_size);

      current->prev = __morestack_current_segment;

      *pp = current;

    }

  current->old_stack = old_stack;

  __morestack_current_segment = current;

  if (dynamic != NULL)

    {

      /* Move the free blocks onto our list.  We don't want to call

         free here, as we are short on stack space.  */

      current->free_dynamic_allocation =

        merge_dynamic_blocks (dynamic, current->free_dynamic_allocation);

    }

  *pframe_size = current->size - param_size;

#ifdef STACK_GROWS_DOWNWARD

  {

    char *bottom = (char *) (current + 1) + current->size;

    to = bottom - param_size;

    ret = bottom - param_size;

  }

#else

  to = current + 1;

  ret = (char *) (current + 1) + param_size;

#endif

  /* We don't call memcpy to avoid worrying about the dynamic linker

     trying to resolve it.  */

  from = (char *) old_stack;

  for (i = 0; i < param_size; i++)

    *to++ = *from++;

  return ret;

}

/* This function is called by a processor specific function when it is

   ready to release a stack segment.  We don't actually release the

   stack segment, we just move back to the previous one.  The current

   stack segment will still be available if we need it in

   __generic_morestack.  This returns a pointer to the new stack

   segment to use, which is the one saved by a previous call to

   __generic_morestack.  The processor specific function is then

   responsible for actually updating the stack pointer.  This sets

   *PAVAILABLE to the amount of stack space now available.  */

void *

__generic_releasestack (size_t *pavailable)

{

  struct stack_segment *current;

  void *old_stack;

  current = __morestack_current_segment;

  old_stack = current->old_stack;

  current = current->prev;

  __morestack_current_segment = current;

  if (current != NULL)

    {

#ifdef STACK_GROWS_DOWNWARD

      *pavailable = (char *) old_stack - (char *) (current + 1);

#else

      *pavailable = (char *) (current + 1) + current->size - (char *) old_stack;

#endif

    }

  else

    {

      size_t used;

      /* We have popped back to the original stack.  */

#ifdef STACK_GROWS_DOWNWARD

      if ((char *) old_stack >= (char *) __morestack_initial_sp.sp)

        used = 0;

      else

        used = (char *) __morestack_initial_sp.sp - (char *) old_stack;

#else

      if ((char *) old_stack <= (char *) __morestack_initial_sp.sp)

        used = 0;

      else

        used = (char *) old_stack - (char *) __morestack_initial_sp.sp;

#endif

      if (used > __morestack_initial_sp.len)

        *pavailable = 0;

      else

        *pavailable = __morestack_initial_sp.len - used;

    }

  return old_stack;

}

/* Block signals while splitting the stack.  This avoids trouble if we

   try to invoke a signal handler which itself wants to split the

   stack.  */

extern int pthread_sigmask (int, const sigset_t *, sigset_t *)

  __attribute__ ((weak));

void

__morestack_block_signals (void)

{

  if (__morestack_initial_sp.dont_block_signals)

    ;

  else if (pthread_sigmask)

    pthread_sigmask (SIG_BLOCK, &__morestack_fullmask,

                     &__morestack_initial_sp.mask);

  else

    sigprocmask (SIG_BLOCK, &__morestack_fullmask,

                 &__morestack_initial_sp.mask);

}

/* Unblock signals while splitting the stack.  */

void

__morestack_unblock_signals (void)

{

  if (__morestack_initial_sp.dont_block_signals)

    ;

  else if (pthread_sigmask)

    pthread_sigmask (SIG_SETMASK, &__morestack_initial_sp.mask, NULL);

  else

    sigprocmask (SIG_SETMASK, &__morestack_initial_sp.mask, NULL);

}

/* This function is called to allocate dynamic stack space, for alloca

   or a variably sized array.  This is a regular function with

   sufficient stack space, so we just use malloc to allocate the

   space.  We attach the allocated blocks to the current stack

   segment, so that they will eventually be reused or freed.  */

void *

__morestack_allocate_stack_space (size_t size)

{

  struct stack_segment *seg, *current;

  struct dynamic_allocation_blocks *p;

  /* We have to block signals to avoid getting confused if we get

     interrupted by a signal whose handler itself uses alloca or a