/*

 * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.

 * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.

 * Copyright (c) 1998 by Fergus Henderson.  All rights reserved.

 * Copyright (c) 2000-2005 by Hewlett-Packard Company.  All rights reserved.

 *

 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED

 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.

 *

 * Permission is hereby granted to use or copy this program

 * for any purpose,  provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 */

#include "private/pthread_support.h"

/*

 * Support code originally for LinuxThreads, the clone()-based kernel

 * thread package for Linux which is included in libc6.

 *

 * This code no doubt makes some assumptions beyond what is

 * guaranteed by the pthread standard, though it now does

 * very little of that.  It now also supports NPTL, and many

 * other Posix thread implementations.  We are trying to merge

 * all flavors of pthread support code into this file.

 */

#if defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS)

# include <stdlib.h>

# include <pthread.h>

# include <sched.h>

# include <time.h>

# include <errno.h>

# include <unistd.h>

# if !defined(GC_RTEMS_PTHREADS)

#   include <sys/mman.h>

# endif

# include <sys/time.h>

# include <sys/types.h>

# include <sys/stat.h>

# include <fcntl.h>

# include <signal.h>

# include "gc_inline.h"

#if defined(GC_DARWIN_THREADS)

# include "private/darwin_semaphore.h"

#else

# include <semaphore.h>

#endif /* !GC_DARWIN_THREADS */

#if defined(GC_DARWIN_THREADS) || defined(GC_FREEBSD_THREADS)

# include <sys/sysctl.h>

#endif /* GC_DARWIN_THREADS */

#if defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS)

# include <sys/param.h>

# include <sys/sysctl.h>

#endif /* GC_NETBSD_THREADS */

/* Allocator lock definitions.          */

#if !defined(USE_SPIN_LOCK)

  GC_INNER pthread_mutex_t GC_allocate_ml = PTHREAD_MUTEX_INITIALIZER;

#endif

#ifdef GC_ASSERTIONS

  GC_INNER unsigned long GC_lock_holder = NO_THREAD;

                /* Used only for assertions.    */

#endif

#if defined(GC_DGUX386_THREADS)

# include <sys/dg_sys_info.h>

# include <sys/_int_psem.h>

  /* sem_t is an uint in DG/UX */

  typedef unsigned int sem_t;

#endif /* GC_DGUX386_THREADS */

/* Undefine macros used to redirect pthread primitives. */

# undef pthread_create

# ifndef GC_NO_PTHREAD_SIGMASK

#   undef pthread_sigmask

# endif

# ifndef GC_NO_PTHREAD_CANCEL

#   undef pthread_cancel

# endif

# ifdef GC_HAVE_PTHREAD_EXIT

#   undef pthread_exit

# endif

# undef pthread_join

# undef pthread_detach

# if defined(GC_OSF1_THREADS) && defined(_PTHREAD_USE_MANGLED_NAMES_) \

     && !defined(_PTHREAD_USE_PTDNAM_)

  /* Restore the original mangled names on Tru64 UNIX.  */

#   define pthread_create __pthread_create

#   define pthread_join __pthread_join

#   define pthread_detach __pthread_detach

#   ifndef GC_NO_PTHREAD_CANCEL

#     define pthread_cancel __pthread_cancel

#   endif

#   ifdef GC_HAVE_PTHREAD_EXIT

#     define pthread_exit __pthread_exit

#   endif

# endif

#ifdef GC_USE_LD_WRAP

#   define WRAP_FUNC(f) __wrap_##f

#   define REAL_FUNC(f) __real_##f

    int REAL_FUNC(pthread_create)(pthread_t *,

                                  GC_PTHREAD_CREATE_CONST pthread_attr_t *,

                                  void *(*start_routine)(void *), void *);

    int REAL_FUNC(pthread_join)(pthread_t, void **);

    int REAL_FUNC(pthread_detach)(pthread_t);

#   ifndef GC_NO_PTHREAD_SIGMASK

      int REAL_FUNC(pthread_sigmask)(int, const sigset_t *, sigset_t *);

#   endif

#   ifndef GC_NO_PTHREAD_CANCEL

      int REAL_FUNC(pthread_cancel)(pthread_t);

#   endif

#   ifdef GC_HAVE_PTHREAD_EXIT

      void REAL_FUNC(pthread_exit)(void *) GC_PTHREAD_EXIT_ATTRIBUTE;

#   endif

#else

#   ifdef GC_USE_DLOPEN_WRAP

#     include <dlfcn.h>

#     define WRAP_FUNC(f) f

#     define REAL_FUNC(f) GC_real_##f

      /* We define both GC_f and plain f to be the wrapped function.    */

      /* In that way plain calls work, as do calls from files that      */

      /* included gc.h, which redefined f to GC_f.                      */

      /* FIXME: Needs work for DARWIN and True64 (OSF1) */

      typedef int (* GC_pthread_create_t)(pthread_t *,

                                    GC_PTHREAD_CREATE_CONST pthread_attr_t *,

                                    void * (*)(void *), void *);

      static GC_pthread_create_t REAL_FUNC(pthread_create);

#     ifndef GC_NO_PTHREAD_SIGMASK

        typedef int (* GC_pthread_sigmask_t)(int, const sigset_t *,

                                             sigset_t *);

        static GC_pthread_sigmask_t REAL_FUNC(pthread_sigmask);

#     endif

      typedef int (* GC_pthread_join_t)(pthread_t, void **);

      static GC_pthread_join_t REAL_FUNC(pthread_join);

      typedef int (* GC_pthread_detach_t)(pthread_t);

      static GC_pthread_detach_t REAL_FUNC(pthread_detach);

#     ifndef GC_NO_PTHREAD_CANCEL

        typedef int (* GC_pthread_cancel_t)(pthread_t);

        static GC_pthread_cancel_t REAL_FUNC(pthread_cancel);

#     endif

#     ifdef GC_HAVE_PTHREAD_EXIT

        typedef void (* GC_pthread_exit_t)(void *) GC_PTHREAD_EXIT_ATTRIBUTE;

        static GC_pthread_exit_t REAL_FUNC(pthread_exit);

#     endif

#   else

#     define WRAP_FUNC(f) GC_##f

#     if !defined(GC_DGUX386_THREADS)

#       define REAL_FUNC(f) f

#     else /* GC_DGUX386_THREADS */

#       define REAL_FUNC(f) __d10_##f

#     endif /* GC_DGUX386_THREADS */

#   endif

#endif

#if defined(GC_USE_LD_WRAP) || defined(GC_USE_DLOPEN_WRAP)

  /* Define GC_ functions as aliases for the plain ones, which will     */

  /* be intercepted.  This allows files which include gc.h, and hence   */

  /* generate references to the GC_ symbols, to see the right symbols.  */

  GC_API int GC_pthread_create(pthread_t * t,

                               GC_PTHREAD_CREATE_CONST pthread_attr_t *a,

                               void * (* fn)(void *), void * arg)

  {

    return pthread_create(t, a, fn, arg);

  }

# ifndef GC_NO_PTHREAD_SIGMASK

    GC_API int GC_pthread_sigmask(int how, const sigset_t *mask,

                                  sigset_t *old)

    {

      return pthread_sigmask(how, mask, old);

    }

# endif /* !GC_NO_PTHREAD_SIGMASK */

  GC_API int GC_pthread_join(pthread_t t, void **res)

  {

    return pthread_join(t, res);

  }

  GC_API int GC_pthread_detach(pthread_t t)

  {

    return pthread_detach(t);

  }

# ifndef GC_NO_PTHREAD_CANCEL

    GC_API int GC_pthread_cancel(pthread_t t)

    {

      return pthread_cancel(t);

    }

# endif /* !GC_NO_PTHREAD_CANCEL */

# ifdef GC_HAVE_PTHREAD_EXIT

    GC_API GC_PTHREAD_EXIT_ATTRIBUTE void GC_pthread_exit(void *retval)

    {

      pthread_exit(retval);

    }

# endif

#endif /* Linker-based interception. */

#ifdef GC_USE_DLOPEN_WRAP

  STATIC GC_bool GC_syms_initialized = FALSE;

  STATIC void GC_init_real_syms(void)

  {

    void *dl_handle;

    if (GC_syms_initialized) return;

#   ifdef RTLD_NEXT

      dl_handle = RTLD_NEXT;

#   else

      dl_handle = dlopen("libpthread.so.0", RTLD_LAZY);

      if (NULL == dl_handle) {

        dl_handle = dlopen("libpthread.so", RTLD_LAZY); /* without ".0" */

      }

      if (NULL == dl_handle) ABORT("Couldn't open libpthread");

#   endif

    REAL_FUNC(pthread_create) = (GC_pthread_create_t)(word)

                                dlsym(dl_handle, "pthread_create");

#   ifdef RTLD_NEXT

      if (REAL_FUNC(pthread_create) == 0)

        ABORT("pthread_create not found"

              " (probably -lgc is specified after -lpthread)");

#   endif

#   ifndef GC_NO_PTHREAD_SIGMASK

      REAL_FUNC(pthread_sigmask) = (GC_pthread_sigmask_t)(word)

                                dlsym(dl_handle, "pthread_sigmask");

#   endif

    REAL_FUNC(pthread_join) = (GC_pthread_join_t)(word)

                                dlsym(dl_handle, "pthread_join");

    REAL_FUNC(pthread_detach) = (GC_pthread_detach_t)(word)

                                  dlsym(dl_handle, "pthread_detach");

#   ifndef GC_NO_PTHREAD_CANCEL

      REAL_FUNC(pthread_cancel) = (GC_pthread_cancel_t)(word)

                                    dlsym(dl_handle, "pthread_cancel");

#   endif

#   ifdef GC_HAVE_PTHREAD_EXIT

      REAL_FUNC(pthread_exit) = (GC_pthread_exit_t)(word)

                                  dlsym(dl_handle, "pthread_exit");

#   endif

    GC_syms_initialized = TRUE;

  }

# define INIT_REAL_SYMS() if (EXPECT(GC_syms_initialized, TRUE)) {} \

                            else GC_init_real_syms()

#else

# define INIT_REAL_SYMS() (void)0

#endif

static GC_bool parallel_initialized = FALSE;

#ifndef GC_ALWAYS_MULTITHREADED

  GC_INNER GC_bool GC_need_to_lock = FALSE;

#endif

STATIC int GC_nprocs = 1;

                        /* Number of processors.  We may not have       */

                        /* access to all of them, but this is as good   */

                        /* a guess as any ...                           */

#ifdef THREAD_LOCAL_ALLOC

  /* We must explicitly mark ptrfree and gcj free lists, since the free */

  /* list links wouldn't otherwise be found.  We also set them in the   */

  /* normal free lists, since that involves touching less memory than   */

  /* if we scanned them normally.                                       */

  GC_INNER void GC_mark_thread_local_free_lists(void)

  {

    int i;

    GC_thread p;

    for (i = 0; i < THREAD_TABLE_SZ; ++i) {

      for (p = GC_threads[i]; 0 != p; p = p -> next) {

        if (!(p -> flags & FINISHED))

          GC_mark_thread_local_fls_for(&(p->tlfs));

      }

    }

  }

# if defined(GC_ASSERTIONS)

    void GC_check_tls_for(GC_tlfs p);

#   if defined(USE_CUSTOM_SPECIFIC)

      void GC_check_tsd_marks(tsd *key);

#   endif

    /* Check that all thread-local free-lists are completely marked.    */

    /* Also check that thread-specific-data structures are marked.      */

    void GC_check_tls(void)

    {

        int i;

        GC_thread p;

        for (i = 0; i < THREAD_TABLE_SZ; ++i) {

          for (p = GC_threads[i]; 0 != p; p = p -> next) {

            if (!(p -> flags & FINISHED))

              GC_check_tls_for(&(p->tlfs));

          }

        }

#       if defined(USE_CUSTOM_SPECIFIC)

          if (GC_thread_key != 0)

            GC_check_tsd_marks(GC_thread_key);

#       endif

    }

# endif /* GC_ASSERTIONS */

#endif /* THREAD_LOCAL_ALLOC */

#ifdef PARALLEL_MARK

# ifndef MAX_MARKERS

#   define MAX_MARKERS 16

# endif

static ptr_t marker_sp[MAX_MARKERS - 1] = {0};

#ifdef IA64

  static ptr_t marker_bsp[MAX_MARKERS - 1] = {0};

#endif

#if defined(GC_DARWIN_THREADS) && !defined(GC_NO_THREADS_DISCOVERY)

  static mach_port_t marker_mach_threads[MAX_MARKERS - 1] = {0};

  /* Used only by GC_suspend_thread_list().     */

  GC_INNER GC_bool GC_is_mach_marker(thread_act_t thread)

  {

    int i;

    for (i = 0; i < GC_markers_m1; i++) {

      if (marker_mach_threads[i] == thread)

        return TRUE;

    }

    return FALSE;

  }

#endif /* GC_DARWIN_THREADS */

STATIC void * GC_mark_thread(void * id)

{

  word my_mark_no = 0;

  IF_CANCEL(int cancel_state;)

  if ((word)id == (word)-1) return 0; /* to make compiler happy */

  DISABLE_CANCEL(cancel_state);

                         /* Mark threads are not cancellable; they      */

                         /* should be invisible to client.              */

  marker_sp[(word)id] = GC_approx_sp();

# ifdef IA64

    marker_bsp[(word)id] = GC_save_regs_in_stack();

# endif

# if defined(GC_DARWIN_THREADS) && !defined(GC_NO_THREADS_DISCOVERY)

    marker_mach_threads[(word)id] = mach_thread_self();

# endif

  /* Inform GC_start_mark_threads about completion of marker data init. */

  GC_acquire_mark_lock();

  if (0 == --GC_fl_builder_count) /* count may have a negative value */

    GC_notify_all_builder();

  for (;; ++my_mark_no) {

    /* GC_mark_no is passed only to allow GC_help_marker to terminate   */

    /* promptly.  This is important if it were called from the signal   */

    /* handler or from the GC lock acquisition code.  Under Linux, it's */

    /* not safe to call it from a signal handler, since it uses mutexes */

    /* and condition variables.  Since it is called only here, the      */

    /* argument is unnecessary.                                         */

    if (my_mark_no < GC_mark_no || my_mark_no > GC_mark_no + 2) {

        /* resynchronize if we get far off, e.g. because GC_mark_no     */

        /* wrapped.                                                     */

        my_mark_no = GC_mark_no;

    }

#   ifdef DEBUG_THREADS

      GC_log_printf("Starting mark helper for mark number %lu\n",

                    (unsigned long)my_mark_no);

#   endif

    GC_help_marker(my_mark_no);

  }

}

STATIC pthread_t GC_mark_threads[MAX_MARKERS];

#ifdef CAN_HANDLE_FORK

  static int available_markers_m1 = 0;

  static pthread_cond_t mark_cv;

                        /* initialized by GC_start_mark_threads_inner   */

#else

# define available_markers_m1 GC_markers_m1

  static pthread_cond_t mark_cv = PTHREAD_COND_INITIALIZER;

#endif

GC_INNER void GC_start_mark_threads_inner(void)

{

    int i;

    pthread_attr_t attr;

#   ifndef NO_MARKER_SPECIAL_SIGMASK

      sigset_t set, oldset;

#   endif

    GC_ASSERT(I_DONT_HOLD_LOCK());

    if (available_markers_m1 <= 0) return;

                /* Skip if parallel markers disabled or already started. */

#   ifdef CAN_HANDLE_FORK

      if (GC_parallel) return;

      /* Initialize mark_cv (for the first time), or cleanup its value  */

      /* after forking in the child process.  All the marker threads in */

      /* the parent process were blocked on this variable at fork, so   */

      /* pthread_cond_wait() malfunction (hang) is possible in the      */

      /* child process without such a cleanup.                          */

      /* TODO: This is not portable, it is better to shortly unblock    */

      /* all marker threads in the parent process at fork.              */

      {

        pthread_cond_t mark_cv_local = PTHREAD_COND_INITIALIZER;

        BCOPY(&mark_cv_local, &mark_cv, sizeof(mark_cv));

      }

#   endif

    GC_ASSERT(GC_fl_builder_count == 0);

    INIT_REAL_SYMS(); /* for pthread_create */

    if (0 != pthread_attr_init(&attr)) ABORT("pthread_attr_init failed");

    if (0 != pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED))

        ABORT("pthread_attr_setdetachstate failed");

#   ifdef DEFAULT_STACK_MAYBE_SMALL

      /* Default stack size is usually too small: increase it.  */

      /* Otherwise marker threads or GC may run out of space.   */

      {

        size_t old_size;

        if (pthread_attr_getstacksize(&attr, &old_size) != 0)

          ABORT("pthread_attr_getstacksize failed");

        if (old_size < MIN_STACK_SIZE

            && old_size != 0 /* stack size is known */) {

          if (pthread_attr_setstacksize(&attr, MIN_STACK_SIZE) != 0)

            ABORT("pthread_attr_setstacksize failed");

        }

      }

#   endif /* DEFAULT_STACK_MAYBE_SMALL */

#   ifndef NO_MARKER_SPECIAL_SIGMASK

      /* Apply special signal mask to GC marker threads, and don't drop */

      /* user defined signals by GC marker threads.                     */

      if (sigfillset(&set) != 0)

        ABORT("sigfillset failed");

#     if !defined(GC_DARWIN_THREADS) && !defined(GC_OPENBSD_UTHREADS) \

         && !defined(NACL)

        /* These are used by GC to stop and restart the world.  */

        if (sigdelset(&set, GC_get_suspend_signal()) != 0

            || sigdelset(&set, GC_get_thr_restart_signal()) != 0)

          ABORT("sigdelset failed");

#     endif

      if (pthread_sigmask(SIG_BLOCK, &set, &oldset) < 0) {

        WARN("pthread_sigmask set failed, no markers started,"

             " errno = %" WARN_PRIdPTR "\n", errno);

        GC_markers_m1 = 0;

        (void)pthread_attr_destroy(&attr);

        return;

      }

#   endif /* !NO_MARKER_SPECIAL_SIGMASK */

#   ifdef CAN_HANDLE_FORK

      /* To have proper GC_parallel value in GC_help_marker.    */

      GC_markers_m1 = available_markers_m1;

#   endif

    for (i = 0; i < available_markers_m1; ++i) {

      if (0 != REAL_FUNC(pthread_create)(GC_mark_threads + i, &attr,

                              GC_mark_thread, (void *)(word)i)) {

        WARN("Marker thread creation failed, errno = %" WARN_PRIdPTR "\n",

             errno);

        /* Don't try to create other marker threads.    */

        GC_markers_m1 = i;

        break;

      }

    }

#   ifndef NO_MARKER_SPECIAL_SIGMASK

      /* Restore previous signal mask.  */

      if (pthread_sigmask(SIG_SETMASK, &oldset, NULL) < 0) {

        WARN("pthread_sigmask restore failed, errno = %" WARN_PRIdPTR "\n",

             errno);

      }

#   endif

    (void)pthread_attr_destroy(&attr);

    GC_wait_for_markers_init();

    GC_COND_LOG_PRINTF("Started %d mark helper threads\n", GC_markers_m1);

}

#endif /* PARALLEL_MARK */

GC_INNER GC_bool GC_thr_initialized = FALSE;

GC_INNER volatile GC_thread GC_threads[THREAD_TABLE_SZ] = {0};

void GC_push_thread_structures(void)

{

    GC_ASSERT(I_HOLD_LOCK());

    GC_PUSH_ALL_SYM(GC_threads);

#   if defined(THREAD_LOCAL_ALLOC)

      GC_PUSH_ALL_SYM(GC_thread_key);

#   endif

}

#ifdef DEBUG_THREADS

  STATIC int GC_count_threads(void)

  {

    int i;

    int count = 0;

    GC_ASSERT(I_HOLD_LOCK());

    for (i = 0; i < THREAD_TABLE_SZ; ++i) {

        GC_thread th = GC_threads[i];

        while (th) {

            if (!(th->flags & FINISHED))

                ++count;

            th = th->next;

        }

    }

    return count;

  }

#endif /* DEBUG_THREADS */

/* It may not be safe to allocate when we register the first thread.    */

static struct GC_Thread_Rep first_thread;

#define THREAD_TABLE_INDEX(id) \

                (int)(((NUMERIC_THREAD_ID(id) >> 16) \

                       ^ (NUMERIC_THREAD_ID(id) >> 8) \

                       ^ NUMERIC_THREAD_ID(id)) % THREAD_TABLE_SZ)

/* Add a thread to GC_threads.  We assume it wasn't already there.      */

/* Caller holds allocation lock.                                        */

STATIC GC_thread GC_new_thread(pthread_t id)

{

    int hv = THREAD_TABLE_INDEX(id);

    GC_thread result;

    static GC_bool first_thread_used = FALSE;

#   ifdef DEBUG_THREADS

        GC_log_printf("Creating thread %p\n", (void *)id);

#   endif

    GC_ASSERT(I_HOLD_LOCK());

    if (!EXPECT(first_thread_used, TRUE)) {

        result = &first_thread;

        first_thread_used = TRUE;

    } else {

        result = (struct GC_Thread_Rep *)

                 GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep), NORMAL);

        if (result == 0) return(0);

    }

    result -> id = id;

#   ifdef USE_TKILL_ON_ANDROID

      result -> kernel_id = gettid();

#   endif

    result -> next = GC_threads[hv];

    GC_threads[hv] = result;

#   ifdef NACL

      GC_nacl_gc_thread_self = result;

      GC_nacl_initialize_gc_thread();

#   endif

    GC_ASSERT(result -> flags == 0 && result -> thread_blocked == 0);

    return(result);

}

/* Delete a thread from GC_threads.  We assume it is there.     */

/* (The code intentionally traps if it wasn't.)                 */

/* It is safe to delete the main thread.                        */

STATIC void GC_delete_thread(pthread_t id)

{

    int hv = THREAD_TABLE_INDEX(id);

    register GC_thread p = GC_threads[hv];

    register GC_thread prev = 0;

#   ifdef DEBUG_THREADS

      GC_log_printf("Deleting thread %p, n_threads = %d\n",

                    (void *)id, GC_count_threads());

#   endif

#   ifdef NACL

      GC_nacl_shutdown_gc_thread();

      GC_nacl_gc_thread_self = NULL;

#   endif

    GC_ASSERT(I_HOLD_LOCK());

    while (!THREAD_EQUAL(p -> id, id)) {

        prev = p;

        p = p -> next;

    }

    if (prev == 0) {

        GC_threads[hv] = p -> next;

    } else {

        prev -> next = p -> next;

    }

    if (p != &first_thread) {

#     ifdef GC_DARWIN_THREADS

        mach_port_deallocate(mach_task_self(), p->stop_info.mach_thread);

#     endif

      GC_INTERNAL_FREE(p);

    }

}

/* If a thread has been joined, but we have not yet             */

/* been notified, then there may be more than one thread        */

/* in the table with the same pthread id.                       */

/* This is OK, but we need a way to delete a specific one.      */

STATIC void GC_delete_gc_thread(GC_thread t)

{

    pthread_t id = t -> id;

    int hv = THREAD_TABLE_INDEX(id);

    register GC_thread p = GC_threads[hv];

    register GC_thread prev = 0;

    GC_ASSERT(I_HOLD_LOCK());

    while (p != t) {

        prev = p;

        p = p -> next;

    }

    if (prev == 0) {

        GC_threads[hv] = p -> next;

    } else {

        prev -> next = p -> next;

    }

#   ifdef GC_DARWIN_THREADS

        mach_port_deallocate(mach_task_self(), p->stop_info.mach_thread);

#   endif

    GC_INTERNAL_FREE(p);

#   ifdef DEBUG_THREADS

      GC_log_printf("Deleted thread %p, n_threads = %d\n",

                    (void *)id, GC_count_threads());

#   endif

}

/* Return a GC_thread corresponding to a given pthread_t.       */

/* Returns 0 if it's not there.                                 */

/* Caller holds allocation lock or otherwise inhibits           */

/* updates.                                                     */

/* If there is more than one thread with the given id we        */

/* return the most recent one.                                  */

GC_INNER GC_thread GC_lookup_thread(pthread_t id)

{

    GC_thread p = GC_threads[THREAD_TABLE_INDEX(id)];

    while (p != 0 && !THREAD_EQUAL(p -> id, id)) p = p -> next;

    return(p);

}

/* Called by GC_finalize() (in case of an allocation failure observed). */

GC_INNER void GC_reset_finalizer_nested(void)

{

  GC_thread me = GC_lookup_thread(pthread_self());

  me->finalizer_nested = 0;

}

/* Checks and updates the thread-local level of finalizers recursion.   */

/* Returns NULL if GC_invoke_finalizers() should not be called by the   */

/* collector (to minimize the risk of a deep finalizers recursion),     */

/* otherwise returns a pointer to the thread-local finalizer_nested.    */

/* Called by GC_notify_or_invoke_finalizers() only (the lock is held).  */

GC_INNER unsigned char *GC_check_finalizer_nested(void)

{

  GC_thread me = GC_lookup_thread(pthread_self());

  unsigned nesting_level = me->finalizer_nested;

  if (nesting_level) {

    /* We are inside another GC_invoke_finalizers().            */

    /* Skip some implicitly-called GC_invoke_finalizers()       */

    /* depending on the nesting (recursion) level.              */

    if (++me->finalizer_skipped < (1U << nesting_level)) return NULL;

    me->finalizer_skipped = 0;

  }

  me->finalizer_nested = (unsigned char)(nesting_level + 1);

  return &me->finalizer_nested;

}

#if defined(GC_ASSERTIONS) && defined(THREAD_LOCAL_ALLOC)

  /* This is called from thread-local GC_malloc(). */

  GC_bool GC_is_thread_tsd_valid(void *tsd)

  {

    GC_thread me;

    DCL_LOCK_STATE;

    LOCK();

    me = GC_lookup_thread(pthread_self());

    UNLOCK();

    return (word)tsd >= (word)(&me->tlfs)

            && (word)tsd < (word)(&me->tlfs) + sizeof(me->tlfs);

  }

#endif /* GC_ASSERTIONS && THREAD_LOCAL_ALLOC */

GC_API int GC_CALL GC_thread_is_registered(void)

{

    pthread_t self = pthread_self();

    GC_thread me;

    DCL_LOCK_STATE;

    LOCK();

    me = GC_lookup_thread(self);

    UNLOCK();

    return me != NULL;

}

static pthread_t main_pthread_id;

static void *main_stack, *main_altstack;

static word main_stack_size, main_altstack_size;

GC_API void GC_CALL GC_register_altstack(void *stack, GC_word stack_size,

                                         void *altstack,

                                         GC_word altstack_size)

{

  GC_thread me;

  pthread_t self = pthread_self();

  DCL_LOCK_STATE;

  LOCK();

  me = GC_lookup_thread(self);

  if (me != NULL) {

    me->stack = stack;

    me->stack_size = stack_size;

    me->altstack = altstack;

    me->altstack_size = altstack_size;

  } else {

    /* This happens if we are called before GC_thr_init.    */

    main_pthread_id = self;

    main_stack = stack;

    main_stack_size = stack_size;

    main_altstack = altstack;

    main_altstack_size = altstack_size;

  }

  UNLOCK();

}

#ifdef CAN_HANDLE_FORK

/* Remove all entries from the GC_threads table, except the     */

/* one for the current thread.  We need to do this in the child */

/* process after a fork(), since only the current thread        */

/* survives in the child.                                       */

STATIC void GC_remove_all_threads_but_me(void)

{

    pthread_t self = pthread_self();

    int hv;

    GC_thread p, next, me;

    for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) {

      me = 0;

      for (p = GC_threads[hv]; 0 != p; p = next) {

        next = p -> next;

        if (THREAD_EQUAL(p -> id, self)

            && me == NULL) { /* ignore dead threads with the same id */

          me = p;

          p -> next = 0;

#         ifdef GC_DARWIN_THREADS

            /* Update thread Id after fork (it is OK to call    */

            /* GC_destroy_thread_local and GC_free_internal     */

            /* before update).                                  */

            me -> stop_info.mach_thread = mach_thread_self();

#         endif

#         ifdef USE_TKILL_ON_ANDROID

            me -> kernel_id = gettid();

#         endif

#         if defined(THREAD_LOCAL_ALLOC) && !defined(USE_CUSTOM_SPECIFIC)

          {

            int res;

            /* Some TLS implementations might be not fork-friendly, so  */

            /* we re-assign thread-local pointer to 'tlfs' for safety   */

            /* instead of the assertion check (again, it is OK to call  */

            /* GC_destroy_thread_local and GC_free_internal before).    */

            res = GC_setspecific(GC_thread_key, &me->tlfs);

            if (COVERT_DATAFLOW(res) != 0)

              ABORT("GC_setspecific failed (in child)");

          }

#         endif

        } else {

#         ifdef THREAD_LOCAL_ALLOC

            if (!(p -> flags & FINISHED)) {

              /* Cannot call GC_destroy_thread_local here.  The free    */

              /* lists may be in an inconsistent state (as thread p may */

              /* be updating one of the lists by GC_generic_malloc_many */

              /* or GC_FAST_MALLOC_GRANS when fork is invoked).         */

              /* This should not be a problem because the lost elements */

              /* of the free lists will be collected during GC.         */

              GC_remove_specific_after_fork(GC_thread_key, p -> id);

            }

#         endif

          if (p != &first_thread) GC_INTERNAL_FREE(p);

        }

      }

      GC_threads[hv] = me;

    }

}

#endif /* CAN_HANDLE_FORK */

#ifdef USE_PROC_FOR_LIBRARIES

  GC_INNER GC_bool GC_segment_is_thread_stack(ptr_t lo, ptr_t hi)

  {

    int i;

    GC_thread p;

    GC_ASSERT(I_HOLD_LOCK());

#   ifdef PARALLEL_MARK

      for (i = 0; i < GC_markers_m1; ++i) {

        if ((word)marker_sp[i] > (word)lo && (word)marker_sp[i] < (word)hi)

          return TRUE;

#       ifdef IA64

          if ((word)marker_bsp[i] > (word)lo

              && (word)marker_bsp[i] < (word)hi)

            return TRUE;

#       endif

      }

#   endif

    for (i = 0; i < THREAD_TABLE_SZ; i++) {

      for (p = GC_threads[i]; p != 0; p = p -> next) {

        if (0 != p -> stack_end) {

#         ifdef STACK_GROWS_UP

            if ((word)p->stack_end >= (word)lo

                && (word)p->stack_end < (word)hi)

              return TRUE;

#         else /* STACK_GROWS_DOWN */

            if ((word)p->stack_end > (word)lo

                && (word)p->stack_end <= (word)hi)

              return TRUE;

#         endif

        }

      }

    }

    return FALSE;

  }

#endif /* USE_PROC_FOR_LIBRARIES */

#ifdef IA64

  /* Find the largest stack_base smaller than bound.  May be used       */

  /* to find the boundary between a register stack and adjacent         */

  /* immediately preceding memory stack.                                */

  GC_INNER ptr_t GC_greatest_stack_base_below(ptr_t bound)

  {

    int i;

    GC_thread p;

    ptr_t result = 0;

    GC_ASSERT(I_HOLD_LOCK());

#   ifdef PARALLEL_MARK

      for (i = 0; i < GC_markers_m1; ++i) {

        if ((word)marker_sp[i] > (word)result

            && (word)marker_sp[i] < (word)bound)

          result = marker_sp[i];

      }

#   endif

    for (i = 0; i < THREAD_TABLE_SZ; i++) {

      for (p = GC_threads[i]; p != 0; p = p -> next) {

        if ((word)p->stack_end > (word)result

            && (word)p->stack_end < (word)bound) {

          result = p -> stack_end;

        }

      }

    }

    return result;

  }

#endif /* IA64 */

#ifndef STAT_READ

  /* Also defined in os_dep.c.  */

# define STAT_BUF_SIZE 4096

# define STAT_READ read

        /* If read is wrapped, this may need to be redefined to call    */

        /* the real one.                                                */

#endif

#ifdef GC_HPUX_THREADS

# define GC_get_nprocs() pthread_num_processors_np()

#elif defined(GC_OSF1_THREADS) || defined(GC_AIX_THREADS) \

      || defined(GC_SOLARIS_THREADS) || defined(GC_GNU_THREADS) \

      || defined(PLATFORM_ANDROID) || defined(NACL)

  GC_INLINE int GC_get_nprocs(void)

  {

    int nprocs = (int)sysconf(_SC_NPROCESSORS_ONLN);