Add gcc-4.6. Synced to @180989

Change-Id: Ie3676586e1d8e3c8cd9f07d022f450d05fa08439
svn://gcc.gnu.org/svn/gcc/branches/google/gcc-4_6-mobile

1 files changed, 732 insertions, 0 deletions

diff --git a/gcc-4.6/libjava/posix-threads.cc b/gcc-4.6/libjava/posix-threads.cc
new file mode 100644
index 000000000..66693abbc
--- /dev/null
+++ b/gcc-4.6/libjava/posix-threads.cc
@@ -0,0 +1,732 @@
+// posix-threads.cc - interface between libjava and POSIX threads.
+
+/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006  Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+// TO DO:
+// * Document signal handling limitations
+
+#include <config.h>
+
+#include "posix.h"
+#include "posix-threads.h"
+
+// If we're using the Boehm GC, then we need to override some of the
+// thread primitives.  This is fairly gross.
+#ifdef HAVE_BOEHM_GC
+#include <gc.h>
+#endif /* HAVE_BOEHM_GC */
+
+#include <stdlib.h>
+#include <time.h>
+#include <signal.h>
+#include <errno.h>
+#include <limits.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>	// To test for _POSIX_THREAD_PRIORITY_SCHEDULING
+#endif
+
+#include <gcj/cni.h>
+#include <jvm.h>
+#include <java/lang/Thread.h>
+#include <java/lang/System.h>
+#include <java/lang/Long.h>
+#include <java/lang/OutOfMemoryError.h>
+#include <java/lang/InternalError.h>
+
+// This is used to implement thread startup.
+struct starter
+{
+  _Jv_ThreadStartFunc *method;
+  _Jv_Thread_t *data;
+};
+
+// This is the key used to map from the POSIX thread value back to the
+// Java object representing the thread.  The key is global to all
+// threads, so it is ok to make it a global here.
+pthread_key_t _Jv_ThreadKey;
+
+// This is the key used to map from the POSIX thread value back to the
+// _Jv_Thread_t* representing the thread.
+pthread_key_t _Jv_ThreadDataKey;
+
+// We keep a count of all non-daemon threads which are running.  When
+// this reaches zero, _Jv_ThreadWait returns.
+static pthread_mutex_t daemon_mutex;
+static pthread_cond_t daemon_cond;
+static int non_daemon_count;
+
+// The signal to use when interrupting a thread.
+#if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
+  // LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
+  // GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
+#  define INTR SIGHUP
+#else /* LINUX_THREADS */
+#  define INTR SIGUSR2
+#endif /* LINUX_THREADS */
+
+//
+// These are the flags that can appear in _Jv_Thread_t.
+//
+
+// Thread started.
+#define FLAG_START   0x01
+// Thread is daemon.
+#define FLAG_DAEMON  0x02
+
+
+
+int
+_Jv_MutexLock (_Jv_Mutex_t *mu)
+{
+  pthread_t self = pthread_self ();
+  if (mu->owner == self)
+    {
+      mu->count++;
+    }
+  else
+    {
+      JvSetThreadState holder (_Jv_ThreadCurrent(), JV_BLOCKED);
+	
+#     ifdef LOCK_DEBUG
+	int result = pthread_mutex_lock (&mu->mutex);
+	if (0 != result)
+	  {
+	    fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
+	    for (;;) {}
+	  }
+#     else
+        pthread_mutex_lock (&mu->mutex);
+#     endif
+      mu->count = 1;
+      mu->owner = self;
+    }
+  return 0;
+}
+
+// Wait for the condition variable "CV" to be notified. 
+// Return values:
+// 0: the condition was notified, or the timeout expired.
+// _JV_NOT_OWNER: the thread does not own the mutex "MU".   
+// _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.   
+int
+_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
+	      jlong millis, jint nanos)
+{
+  pthread_t self = pthread_self();
+  if (mu->owner != self)
+    return _JV_NOT_OWNER;
+
+  struct timespec ts;
+
+  JvThreadState new_state = JV_WAITING;
+  if (millis > 0 || nanos > 0)
+    {
+      // Calculate the abstime corresponding to the timeout.
+      unsigned long long seconds;
+      unsigned long usec;
+
+      // For better accuracy, should use pthread_condattr_setclock
+      // and clock_gettime.
+#ifdef HAVE_GETTIMEOFDAY
+      timeval tv;
+      gettimeofday (&tv, NULL);
+      usec = tv.tv_usec;
+      seconds = tv.tv_sec;
+#else
+      unsigned long long startTime = java::lang::System::currentTimeMillis();
+      seconds = startTime / 1000;
+      /* Assume we're about half-way through this millisecond.  */
+      usec = (startTime % 1000) * 1000 + 500;
+#endif
+      /* These next two statements cannot overflow.  */
+      usec += nanos / 1000;
+      usec += (millis % 1000) * 1000;
+      /* These two statements could overflow only if tv.tv_sec was
+	 insanely large.  */
+      seconds += millis / 1000;
+      seconds += usec / 1000000;
+
+      ts.tv_sec = seconds;
+      if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
+        {
+          // We treat a timeout that won't fit into a struct timespec
+          // as a wait forever.
+          millis = nanos = 0;
+        }
+      else
+	/* This next statement also cannot overflow.  */
+	ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
+    }
+
+  _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
+  java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
+
+  pthread_mutex_lock (&current->wait_mutex);
+
+  // Now that we hold the wait mutex, check if this thread has been 
+  // interrupted already.
+  if (current_obj->interrupt_flag)
+    {
+      pthread_mutex_unlock (&current->wait_mutex);
+      return _JV_INTERRUPTED;
+    }
+
+  // Set the thread's state.
+  JvSetThreadState holder (current_obj, new_state);
+
+  // Add this thread to the cv's wait set.
+  current->next = NULL;
+
+  if (cv->first == NULL)
+    cv->first = current;
+  else
+    for (_Jv_Thread_t *t = cv->first;; t = t->next)
+      {
+        if (t->next == NULL)
+          {
+            t->next = current;
+            break;
+          }
+      }
+
+  // Record the current lock depth, so it can be restored when we re-aquire it.
+  int count = mu->count;
+
+  // Release the monitor mutex.
+  mu->count = 0;
+  mu->owner = 0;
+  pthread_mutex_unlock (&mu->mutex);
+  
+  int r = 0;
+  bool done_sleeping = false;
+
+  while (! done_sleeping)
+    {
+      if (millis == 0 && nanos == 0)
+	r = pthread_cond_wait (&current->wait_cond, &current->wait_mutex);
+      else
+	r = pthread_cond_timedwait (&current->wait_cond, &current->wait_mutex, 
+				    &ts);
+
+      // In older glibc's (prior to 2.1.3), the cond_wait functions may 
+      // spuriously wake up on a signal. Catch that here.
+      if (r != EINTR)
+        done_sleeping = true;
+    }
+  
+  // Check for an interrupt *before* releasing the wait mutex.
+  jboolean interrupted = current_obj->interrupt_flag;
+  
+  pthread_mutex_unlock (&current->wait_mutex);
+
+  //  Reaquire the monitor mutex, and restore the lock count.
+  pthread_mutex_lock (&mu->mutex);
+  mu->owner = self;
+  mu->count = count;
+
+  // If we were interrupted, or if a timeout occurred, remove ourself from
+  // the cv wait list now. (If we were notified normally, notify() will have
+  // already taken care of this)
+  if (r == ETIMEDOUT || interrupted)
+    {
+      _Jv_Thread_t *prev = NULL;
+      for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
+        {
+	  if (t == current)
+	    {
+	      if (prev != NULL)
+		prev->next = t->next;
+	      else
+	        cv->first = t->next;
+	      t->next = NULL;
+	      break;
+	    }
+	  prev = t;
+	}
+      if (interrupted)
+	return _JV_INTERRUPTED;
+    }
+  
+  return 0;
+}
+
+int
+_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
+{
+  if (_Jv_MutexCheckMonitor (mu))
+    return _JV_NOT_OWNER;
+
+  _Jv_Thread_t *target;
+  _Jv_Thread_t *prev = NULL;
+
+  for (target = cv->first; target != NULL; target = target->next)
+    {
+      pthread_mutex_lock (&target->wait_mutex);
+
+      if (target->thread_obj->interrupt_flag)
+        {
+	  // Don't notify a thread that has already been interrupted.
+	  pthread_mutex_unlock (&target->wait_mutex);
+          prev = target;
+	  continue;
+	}
+
+      pthread_cond_signal (&target->wait_cond);
+      pthread_mutex_unlock (&target->wait_mutex);
+
+      // Two concurrent notify() calls must not be delivered to the same 
+      // thread, so remove the target thread from the cv wait list now.
+      if (prev == NULL)
+	cv->first = target->next;
+      else
+        prev->next = target->next;
+		
+      target->next = NULL;
+      
+      break;
+    }
+
+  return 0;
+}
+
+int
+_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
+{
+  if (_Jv_MutexCheckMonitor (mu))
+    return _JV_NOT_OWNER;
+
+  _Jv_Thread_t *target;
+  _Jv_Thread_t *prev = NULL;
+
+  for (target = cv->first; target != NULL; target = target->next)
+    {
+      pthread_mutex_lock (&target->wait_mutex);
+      pthread_cond_signal (&target->wait_cond);
+      pthread_mutex_unlock (&target->wait_mutex);
+
+      if (prev != NULL)
+	prev->next = NULL;
+      prev = target;
+    }
+  if (prev != NULL)
+    prev->next = NULL;
+    
+  cv->first = NULL;
+
+  return 0;
+}
+
+void
+_Jv_ThreadInterrupt (_Jv_Thread_t *data)
+{
+  pthread_mutex_lock (&data->wait_mutex);
+
+  // Set the thread's interrupted flag *after* aquiring its wait_mutex. This
+  // ensures that there are no races with the interrupt flag being set after 
+  // the waiting thread checks it and before pthread_cond_wait is entered.
+  data->thread_obj->interrupt_flag = true;
+
+  // Interrupt blocking system calls using a signal.
+  pthread_kill (data->thread, INTR);
+  
+  pthread_cond_signal (&data->wait_cond);
+  
+  pthread_mutex_unlock (&data->wait_mutex);
+}
+
+/**
+ * Releases the block on a thread created by _Jv_ThreadPark().  This
+ * method can also be used to terminate a blockage caused by a prior
+ * call to park.  This operation is unsafe, as the thread must be
+ * guaranteed to be live.
+ *
+ * @param thread the thread to unblock.
+ */
+void
+ParkHelper::unpark ()
+{
+  using namespace ::java::lang;
+  volatile obj_addr_t *ptr = &permit;
+
+  /* If this thread is in state RUNNING, give it a permit and return
+     immediately.  */
+  if (compare_and_swap 
+      (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PERMIT))
+    return;
+
+  /* If this thread is parked, put it into state RUNNING and send it a
+     signal.  */
+  if (compare_and_swap
+      (ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING))
+    {
+      int result;
+      pthread_mutex_lock (&mutex);
+      result = pthread_cond_signal (&cond);
+      pthread_mutex_unlock (&mutex);
+      JvAssert (result == 0);
+    }
+}
+
+/**
+ * Sets our state to dead.
+ */
+void
+ParkHelper::deactivate ()
+{
+  permit = ::java::lang::Thread::THREAD_PARK_DEAD;
+}
+
+void
+ParkHelper::init ()
+{
+  pthread_mutex_init (&mutex, NULL);
+  pthread_cond_init (&cond, NULL);
+  permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
+}
+
+/**
+ * Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
+ * thread is interrupted or the optional timeout expires.  If an
+ * unpark call has already occurred, this also counts.  A timeout
+ * value of zero is defined as no timeout.  When isAbsolute is true,
+ * the timeout is in milliseconds relative to the epoch.  Otherwise,
+ * the value is the number of nanoseconds which must occur before
+ * timeout.  This call may also return spuriously (i.e.  for no
+ * apparent reason).
+ *
+ * @param isAbsolute true if the timeout is specified in milliseconds from
+ *                   the epoch.
+ * @param time either the number of nanoseconds to wait, or a time in
+ *             milliseconds from the epoch to wait for.
+ */
+void
+ParkHelper::park (jboolean isAbsolute, jlong time)
+{
+  using namespace ::java::lang;
+  volatile obj_addr_t *ptr = &permit;
+
+  /* If we have a permit, return immediately.  */
+  if (compare_and_swap 
+      (ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
+    return;
+
+  struct timespec ts;
+
+  if (time)
+    {
+      unsigned long long seconds;
+      unsigned long usec;
+
+      if (isAbsolute)
+	{
+	  ts.tv_sec = time / 1000;
+	  ts.tv_nsec = (time % 1000) * 1000 * 1000;
+	}
+      else
+	{
+	  // Calculate the abstime corresponding to the timeout.
+	  jlong nanos = time;
+	  jlong millis = 0;
+
+	  // For better accuracy, should use pthread_condattr_setclock
+	  // and clock_gettime.
+#ifdef HAVE_GETTIMEOFDAY
+	  timeval tv;
+	  gettimeofday (&tv, NULL);
+	  usec = tv.tv_usec;
+	  seconds = tv.tv_sec;
+#else
+	  unsigned long long startTime
+	    = java::lang::System::currentTimeMillis();
+	  seconds = startTime / 1000;
+	  /* Assume we're about half-way through this millisecond.  */
+	  usec = (startTime % 1000) * 1000 + 500;
+#endif
+	  /* These next two statements cannot overflow.  */
+	  usec += nanos / 1000;
+	  usec += (millis % 1000) * 1000;
+	  /* These two statements could overflow only if tv.tv_sec was
+	     insanely large.  */
+	  seconds += millis / 1000;
+	  seconds += usec / 1000000;
+
+	  ts.tv_sec = seconds;
+	  if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
+	    {
+	      // We treat a timeout that won't fit into a struct timespec
+	      // as a wait forever.
+	      millis = nanos = 0;
+	    }
+	  else
+	    /* This next statement also cannot overflow.  */
+	    ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
+	}
+    }
+
+  pthread_mutex_lock (&mutex);
+  if (compare_and_swap 
+      (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
+    {
+      int result = 0;
+
+      if (! time)
+	result = pthread_cond_wait (&cond, &mutex);
+      else
+	result = pthread_cond_timedwait (&cond, &mutex, &ts);
+
+      JvAssert (result == 0 || result == ETIMEDOUT);
+
+      /* If we were unparked by some other thread, this will already
+	 be in state THREAD_PARK_RUNNING.  If we timed out or were
+	 interrupted, we have to do it ourself.  */
+      permit = Thread::THREAD_PARK_RUNNING;
+    }
+  pthread_mutex_unlock (&mutex);
+}
+
+static void
+handle_intr (int)
+{
+  // Do nothing.
+}
+
+void
+_Jv_BlockSigchld()
+{
+  sigset_t mask;
+  sigemptyset (&mask);
+  sigaddset (&mask, SIGCHLD);
+  int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
+  if (c != 0)
+    JvFail (strerror (c));
+}
+
+void
+_Jv_UnBlockSigchld()
+{
+  sigset_t mask;
+  sigemptyset (&mask);
+  sigaddset (&mask, SIGCHLD);
+  int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
+  if (c != 0)
+    JvFail (strerror (c));
+}
+
+void
+_Jv_InitThreads (void)
+{
+  pthread_key_create (&_Jv_ThreadKey, NULL);
+  pthread_key_create (&_Jv_ThreadDataKey, NULL);
+  pthread_mutex_init (&daemon_mutex, NULL);
+  pthread_cond_init (&daemon_cond, 0);
+  non_daemon_count = 0;
+
+  // Arrange for the interrupt signal to interrupt system calls.
+  struct sigaction act;
+  act.sa_handler = handle_intr;
+  sigemptyset (&act.sa_mask);
+  act.sa_flags = 0;
+  sigaction (INTR, &act, NULL);
+
+  // Block SIGCHLD here to ensure that any non-Java threads inherit the new 
+  // signal mask.
+  _Jv_BlockSigchld();
+
+  // Check/set the thread stack size.
+  size_t min_ss = 32 * 1024;
+  
+  if (sizeof (void *) == 8)
+    // Bigger default on 64-bit systems.
+    min_ss *= 2;
+
+#ifdef PTHREAD_STACK_MIN
+  if (min_ss < PTHREAD_STACK_MIN)
+    min_ss = PTHREAD_STACK_MIN;
+#endif
+  
+  if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
+    gcj::stack_size = min_ss;
+}
+
+_Jv_Thread_t *
+_Jv_ThreadInitData (java::lang::Thread *obj)
+{
+  _Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
+  data->flags = 0;
+  data->thread_obj = obj;
+
+  pthread_mutex_init (&data->wait_mutex, NULL);
+  pthread_cond_init (&data->wait_cond, NULL);
+
+  return data;
+}
+
+void
+_Jv_ThreadDestroyData (_Jv_Thread_t *data)
+{
+  pthread_mutex_destroy (&data->wait_mutex);
+  pthread_cond_destroy (&data->wait_cond);
+  _Jv_Free ((void *)data);
+}
+
+void
+_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
+{
+#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
+  if (data->flags & FLAG_START)
+    {
+      struct sched_param param;
+
+      param.sched_priority = prio;
+      pthread_setschedparam (data->thread, SCHED_OTHER, &param);
+    }
+#endif
+}
+
+void
+_Jv_ThreadRegister (_Jv_Thread_t *data)
+{
+  pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
+  pthread_setspecific (_Jv_ThreadDataKey, data);
+
+  // glibc 2.1.3 doesn't set the value of `thread' until after start_routine
+  // is called. Since it may need to be accessed from the new thread, work 
+  // around the potential race here by explicitly setting it again.
+  data->thread = pthread_self ();
+
+# ifdef SLOW_PTHREAD_SELF
+    // Clear all self cache slots that might be needed by this thread.
+    int dummy;
+    int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
+    int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
+    for (int i = low_index; i <= high_index; ++i) 
+      {
+        int current_index = i;
+	if (current_index < 0)
+	  current_index += SELF_CACHE_SIZE;
+	if (current_index >= SELF_CACHE_SIZE)
+	  current_index -= SELF_CACHE_SIZE;
+	_Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
+      }
+# endif
+  // Block SIGCHLD which is used in natPosixProcess.cc.
+  _Jv_BlockSigchld();
+}
+
+void
+_Jv_ThreadUnRegister ()
+{
+  pthread_setspecific (_Jv_ThreadKey, NULL);
+  pthread_setspecific (_Jv_ThreadDataKey, NULL);
+}
+
+// This function is called when a thread is started.  We don't arrange
+// to call the `run' method directly, because this function must
+// return a value.
+static void *
+really_start (void *x)
+{
+  struct starter *info = (struct starter *) x;
+
+  _Jv_ThreadRegister (info->data);
+
+  info->method (info->data->thread_obj);
+
+  if (! (info->data->flags & FLAG_DAEMON))
+    {
+      pthread_mutex_lock (&daemon_mutex);
+      --non_daemon_count;
+      if (! non_daemon_count)
+	pthread_cond_signal (&daemon_cond);
+      pthread_mutex_unlock (&daemon_mutex);
+    }
+
+  return NULL;
+}
+
+void
+_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
+		 _Jv_ThreadStartFunc *meth)
+{
+  struct sched_param param;
+  pthread_attr_t attr;
+  struct starter *info;
+
+  if (data->flags & FLAG_START)
+    return;
+  data->flags |= FLAG_START;
+
+  // Block SIGCHLD which is used in natPosixProcess.cc.
+  // The current mask is inherited by the child thread.
+  _Jv_BlockSigchld();
+
+  param.sched_priority = thread->getPriority();
+
+  pthread_attr_init (&attr);
+  pthread_attr_setschedparam (&attr, &param);
+  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+  
+  // Set stack size if -Xss option was given.
+  if (gcj::stack_size > 0)
+    {
+      int e = pthread_attr_setstacksize (&attr, gcj::stack_size);
+      if (e != 0)
+	JvFail (strerror (e));
+    }
+
+  info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
+  info->method = meth;
+  info->data = data;
+
+  if (! thread->isDaemon())
+    {
+      pthread_mutex_lock (&daemon_mutex);
+      ++non_daemon_count;
+      pthread_mutex_unlock (&daemon_mutex);
+    }
+  else
+    data->flags |= FLAG_DAEMON;
+  int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
+  
+  pthread_attr_destroy (&attr);
+
+  if (r)
+    {
+      const char* msg = "Cannot create additional threads";
+      throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
+    }
+}
+
+void
+_Jv_ThreadWait (void)
+{
+  pthread_mutex_lock (&daemon_mutex);
+  if (non_daemon_count)
+    pthread_cond_wait (&daemon_cond, &daemon_mutex);
+  pthread_mutex_unlock (&daemon_mutex);
+}
+
+#if defined(SLOW_PTHREAD_SELF)
+
+#include "sysdep/locks.h"
+
+// Support for pthread_self() lookup cache.
+volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
+
+_Jv_ThreadId_t
+_Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
+{
+  pthread_t self = pthread_self();
+  sce -> high_sp_bits = high_sp_bits;
+  write_barrier();
+  sce -> self = self;
+  return self;
+}
+
+#endif /* SLOW_PTHREAD_SELF */