Subversion Repositories openrisc

// natThread.cc - Native part of Thread class.
 
/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2005, 2006, 2007  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.  */
 
#include <config.h>
 
#include <stdlib.h>
 
#include <gcj/cni.h>
#include <jvm.h>
#include <java-threads.h>
 
#include <gnu/gcj/RawDataManaged.h>
#include <java/lang/Thread.h>
#include <java/lang/Thread$State.h>
#include <java/lang/Thread$UncaughtExceptionHandler.h>
#include <java/lang/ThreadGroup.h>
#include <java/lang/IllegalArgumentException.h>
#include <java/lang/IllegalThreadStateException.h>
#include <java/lang/InterruptedException.h>
#include <java/lang/NullPointerException.h>
 
#include <jni.h>
 
#ifdef INTERPRETER
#include <jvmti.h>
#include "jvmti-int.h"
#endif
 
#ifdef ENABLE_JVMPI
#include <jvmpi.h>
#endif
 

 
static void finalize_native (jobject ptr);
 
// This is called from the constructor to initialize the native side
// of the Thread.
void
java::lang::Thread::initialize_native (void)
{
  natThread *nt = (natThread *) _Jv_AllocBytes (sizeof (natThread));
 
  state = JV_NEW;
  nt->alive_flag = THREAD_DEAD;
 
  data = (gnu::gcj::RawDataManaged *) nt;
 
  // Register a finalizer to clean up the native thread resources.
  _Jv_RegisterFinalizer (data, finalize_native);
 
  _Jv_MutexInit (&nt->join_mutex);
  _Jv_CondInit (&nt->join_cond);
 
  nt->park_helper.init();
 
  nt->thread = _Jv_ThreadInitData (this);
  // FIXME: if JNI_ENV is set we will want to free it.  It is
  // malloc()d.
  nt->jni_env = NULL;
}
 
static void
finalize_native (jobject ptr)
{
  natThread *nt = (natThread *) ptr;
  _Jv_ThreadDestroyData (nt->thread);
#ifdef _Jv_HaveCondDestroy
  _Jv_CondDestroy (&nt->join_cond);
#endif
#ifdef _Jv_HaveMutexDestroy
  _Jv_MutexDestroy (&nt->join_mutex);
#endif
  _Jv_FreeJNIEnv((JNIEnv*)nt->jni_env);
 
  nt->park_helper.destroy();
}
 
jint
java::lang::Thread::countStackFrames (void)
{
  // NOTE: This is deprecated in JDK 1.2.
 
  // Old applets still call this method.  Rather than throwing
  // UnsupportedOperationException we simply fail silently.
 
  return 0;
}
 
java::lang::Thread *
java::lang::Thread::currentThread (void)
{
  return _Jv_ThreadCurrent ();
}
 
jboolean
java::lang::Thread::holdsLock (jobject obj)
{
  if (!obj)
    throw new NullPointerException;
  return !_Jv_ObjectCheckMonitor (obj);
}
 
jboolean
java::lang::Thread::isAlive (void)
{
  natThread *nt = (natThread *) data;
  return nt->alive_flag != (obj_addr_t)THREAD_DEAD;
}
 
void
java::lang::Thread::interrupt (void)
{
  checkAccess ();
 
  natThread *nt = (natThread *) data;
 
  // If a thread is in state ALIVE, we atomically set it to state
  // SIGNALED and send it a signal.  Once we've sent it the signal, we
  // set its state back to ALIVE.
  if (compare_and_swap 
      (&nt->alive_flag, Thread::THREAD_ALIVE, Thread::THREAD_SIGNALED))
    {
      _Jv_ThreadInterrupt (nt->thread);
      compare_and_swap 
	(&nt->alive_flag, THREAD_SIGNALED, Thread::THREAD_ALIVE);
 
      // Even though we've interrupted this thread, it might still be
      // parked.
      nt->park_helper.unpark ();
    }
}
 
void
java::lang::Thread::join (jlong millis, jint nanos)
{
  if (millis < 0 || nanos < 0 || nanos > 999999)
    throw new IllegalArgumentException;
 
  Thread *current = currentThread ();
 
  // Here `NT' is the native structure for the thread we are trying to join.
  natThread *nt = (natThread *) data;
 
  // Now wait for: (1) an interrupt, (2) the thread to exit, or (3)
  // the timeout to occur. 
  _Jv_MutexLock (&nt->join_mutex);
  if (! isAlive ())
    {
      _Jv_MutexUnlock (&nt->join_mutex);
      return;
    }
  _Jv_CondWait (&nt->join_cond, &nt->join_mutex, millis, nanos);
  _Jv_MutexUnlock (&nt->join_mutex);
 
  if (current->isInterrupted (true))
    throw new InterruptedException;
}
 
void
java::lang::Thread::resume (void)
{
  checkAccess ();
 
  // Old applets still call this method.  Rather than throwing
  // UnsupportedOperationException we simply fail silently.
}
 
void
java::lang::Thread::setPriority (jint newPriority)
{
  checkAccess ();
  if (newPriority < MIN_PRIORITY || newPriority > MAX_PRIORITY)
    throw new IllegalArgumentException;
 
  jint gmax = group->getMaxPriority();
  if (newPriority > gmax)
    newPriority = gmax;
 
  priority = newPriority;
  natThread *nt = (natThread *) data;
  _Jv_ThreadSetPriority (nt->thread, priority);
}
 
void
java::lang::Thread::sleep (jlong millis, jint nanos)
{
  if (millis < 0 || nanos < 0 || nanos > 999999)
    throw new IllegalArgumentException;
 
  if (millis == 0 && nanos == 0)
    ++nanos;
 
  Thread *current = currentThread ();
 
  // We use a condition variable to implement sleeping so that an
  // interrupt can wake us up. 
  natThread *nt = (natThread *) current->data;
  _Jv_MutexLock (&nt->join_mutex);
  _Jv_CondWait (&nt->join_cond, &nt->join_mutex, millis, nanos);
  _Jv_MutexUnlock (&nt->join_mutex);
 
  if (current->isInterrupted (true))
    throw new InterruptedException;
}
 
void
java::lang::Thread::finish_ ()
{
  __sync_synchronize();
  natThread *nt = (natThread *) data;
 
  nt->park_helper.deactivate ();
  group->removeThread (this);
 
#ifdef INTERPRETER
  if (JVMTI_REQUESTED_EVENT (ThreadEnd))
    _Jv_JVMTI_PostEvent (JVMTI_EVENT_THREAD_END, this, nt->jni_env);
#endif
 
#ifdef ENABLE_JVMPI  
  if (_Jv_JVMPI_Notify_THREAD_END)
    {
      JVMPI_Event event;
 
      event.event_type = JVMPI_EVENT_THREAD_END;
      event.env_id = _Jv_GetCurrentJNIEnv ();
 
      _Jv_DisableGC ();
      (*_Jv_JVMPI_Notify_THREAD_END) (&event);
      _Jv_EnableGC ();
    }
#endif
 
  // If a method cache was created, free it.
  _Jv_FreeMethodCache();
 
  // Clear out thread locals.
  locals = NULL;
 
  // Signal any threads that are waiting to join() us.
  _Jv_MutexLock (&nt->join_mutex);
 
  {
    JvSynchronize sync (this);
    nt->alive_flag = THREAD_DEAD;
    state = JV_TERMINATED;
  }
 
  _Jv_CondNotifyAll (&nt->join_cond, &nt->join_mutex);
  _Jv_MutexUnlock (&nt->join_mutex);  
}
 
// Run once at thread startup, either when thread is attached or when 
// _Jv_ThreadRun is called.
static void
_Jv_NotifyThreadStart (java::lang::Thread* thread)
{
#ifdef INTERPRETER
  if (JVMTI_REQUESTED_EVENT (ThreadStart))
    {
      natThread *nt = reinterpret_cast<natThread *> (thread->data);
      _Jv_JVMTI_PostEvent (JVMTI_EVENT_THREAD_START, thread, nt->jni_env);
    }
#endif
 
#ifdef ENABLE_JVMPI
      if (_Jv_JVMPI_Notify_THREAD_START)
	{
	  JVMPI_Event event;
 
	  jstring thread_name = thread->getName ();
	  jstring group_name = NULL, parent_name = NULL;
	  java::lang::ThreadGroup *group = thread->getThreadGroup ();
 
	  if (group)
	    {
	      group_name = group->getName ();
	      group = group->getParent ();
 
	      if (group)
		parent_name = group->getName ();
	    }
 
	  int thread_len = thread_name ? JvGetStringUTFLength (thread_name) : 0;
	  int group_len = group_name ? JvGetStringUTFLength (group_name) : 0;
	  int parent_len = parent_name ? JvGetStringUTFLength (parent_name) : 0;
 
	  char thread_chars[thread_len + 1];
	  char group_chars[group_len + 1];
	  char parent_chars[parent_len + 1];
 
	  if (thread_name)
	    JvGetStringUTFRegion (thread_name, 0, 
				  thread_name->length(), thread_chars);
	  if (group_name)
	    JvGetStringUTFRegion (group_name, 0, 
				  group_name->length(), group_chars);
	  if (parent_name)
	    JvGetStringUTFRegion (parent_name, 0, 
				  parent_name->length(), parent_chars);
 
	  thread_chars[thread_len] = '\0';
	  group_chars[group_len] = '\0';
	  parent_chars[parent_len] = '\0';
 
	  event.event_type = JVMPI_EVENT_THREAD_START;
	  event.env_id = NULL;
	  event.u.thread_start.thread_name = thread_chars;
	  event.u.thread_start.group_name = group_chars;
	  event.u.thread_start.parent_name = parent_chars;
	  event.u.thread_start.thread_id = (jobjectID) thread;
	  event.u.thread_start.thread_env_id = _Jv_GetCurrentJNIEnv ();
 
	  _Jv_DisableGC ();
	  (*_Jv_JVMPI_Notify_THREAD_START) (&event);
	  _Jv_EnableGC ();
	}
#endif
}
 
void
_Jv_ThreadRun (java::lang::Thread* thread)
{
  try
    {
      _Jv_NotifyThreadStart (thread);
      thread->run ();
    }
  catch (java::lang::Throwable *t)
    {
      // Uncaught exceptions are forwarded to the ThreadGroup.  If
      // this results in an uncaught exception, that is ignored.
      try
	{
	  thread->getUncaughtExceptionHandler()->uncaughtException (thread, t);
	}
      catch (java::lang::Throwable *f)
	{
	  // Nothing.
	}
    }
 
  thread->finish_ ();
}
 
_Jv_Thread_t*
_Jv_ThreadGetData (java::lang::Thread* thread)
{
  natThread* nt = (natThread*) thread->data;
  return nt->thread;
}
 
void
java::lang::Thread::start (void)
{
  JvSynchronize sync (this);
 
  // Its illegal to re-start() a thread, even if its dead.
  if (!startable_flag)
    throw new IllegalThreadStateException;
 
  natThread *nt = (natThread *) data;
  nt->alive_flag = THREAD_ALIVE;
  startable_flag = false;
  state = JV_RUNNABLE;
  _Jv_ThreadStart (this, nt->thread, (_Jv_ThreadStartFunc *) &_Jv_ThreadRun);
}
 
void
java::lang::Thread::stop (java::lang::Throwable *)
{
  checkAccess ();
 
  // Old applets still call this method.  Rather than throwing
  // UnsupportedOperationException we simply fail silently.
}
 
void
java::lang::Thread::suspend (void)
{
  checkAccess ();
 
  // Old applets still call this method.  Rather than throwing
  // UnsupportedOperationException we simply fail silently.
}
 
static int nextThreadNumber = 0;
 
jstring
java::lang::Thread::gen_name (void)
{
  jint i;
  jclass sync = &java::lang::Thread::class$;
  {
    JvSynchronize dummy(sync); 
    i = ++nextThreadNumber;
  }
 
  // Use an array large enough for "-2147483648"; i.e. 11 chars, + "Thread-".
  jchar buffer[7+11];
  jchar *bufend = (jchar *) ((char *) buffer + sizeof(buffer));
  i = _Jv_FormatInt (bufend, i);
  jchar *ptr = bufend - i;
  // Prepend "Thread-".
  *--ptr = '-';
  *--ptr = 'd';
  *--ptr = 'a';
  *--ptr = 'e';
  *--ptr = 'r';
  *--ptr = 'h';
  *--ptr = 'T';
  return JvNewString (ptr, bufend - ptr);
}
 
void
java::lang::Thread::yield (void)
{
  _Jv_ThreadYield ();
}
 
::java::lang::Thread$State *
java::lang::Thread::getState()
{
  _Jv_InitClass(&::java::lang::Thread$State::class$);
 
  switch (state)
    {
    case JV_BLOCKED:
      return ::java::lang::Thread$State::BLOCKED;
    case JV_NEW:
      return ::java::lang::Thread$State::NEW;
 
    case JV_RUNNABLE:
      return ::java::lang::Thread$State::RUNNABLE;
    case JV_TERMINATED:
      return ::java::lang::Thread$State::TERMINATED;
    case JV_TIMED_WAITING:
      return ::java::lang::Thread$State::TIMED_WAITING;
    case JV_WAITING:
      return ::java::lang::Thread$State::WAITING;
    }
 
  // We don't really need a default, but this makes the compiler
  // happy.
  return ::java::lang::Thread$State::RUNNABLE;
}
 
JNIEnv *
_Jv_GetCurrentJNIEnv ()
{
  java::lang::Thread *t = _Jv_ThreadCurrent ();
  if (t == NULL)
    return NULL;
  return ((natThread *) t->data)->jni_env;
}
 
void
_Jv_SetCurrentJNIEnv (JNIEnv *env)
{
  java::lang::Thread *t = _Jv_ThreadCurrent ();
  JvAssert (t != NULL);
  ((natThread *) t->data)->jni_env = env;
}
 
// Attach the current native thread to an existing (but unstarted) Thread 
// object. Does not register thread with the garbage collector.
// Returns -1 on failure, 0 upon success.
jint
_Jv_AttachCurrentThread(java::lang::Thread* thread)
{
  JvSynchronize sync (thread);
  if (thread == NULL || thread->startable_flag == false)
    return -1;
  thread->startable_flag = false;
  natThread *nt = (natThread *) thread->data;
  nt->alive_flag = ::java::lang::Thread::THREAD_ALIVE;
  thread->state = JV_RUNNABLE;
  _Jv_ThreadRegister (nt->thread);
  return 0;
}
 
java::lang::Thread*
_Jv_AttachCurrentThread(jstring name, java::lang::ThreadGroup* group)
{
  // Register thread with GC before attempting any allocations.
  _Jv_GCAttachThread ();
  java::lang::Thread *thread = _Jv_ThreadCurrent ();
  if (thread != NULL)
    return thread;
  if (name == NULL)
    name = java::lang::Thread::gen_name ();
  thread = new java::lang::Thread (NULL, group, NULL, name, false);
  _Jv_AttachCurrentThread (thread);
  _Jv_NotifyThreadStart (thread);
  return thread;
}
 
java::lang::Thread*
_Jv_AttachCurrentThreadAsDaemon(jstring name, java::lang::ThreadGroup* group)
{
  java::lang::Thread *thread = _Jv_ThreadCurrent ();
  if (thread != NULL)
    return thread;
  if (name == NULL)
    name = java::lang::Thread::gen_name ();
  thread = new java::lang::Thread (NULL, group, NULL, name, false);
  thread->setDaemon (true);
  _Jv_AttachCurrentThread (thread);
  _Jv_NotifyThreadStart (thread);
  return thread;
}
 
jint
_Jv_DetachCurrentThread (void)
{
  java::lang::Thread *t = _Jv_ThreadCurrent ();
  if (t == NULL)
    return -1;
 
  _Jv_ThreadUnRegister ();
  _Jv_GCDetachThread ();
  // Release the monitors.
  t->finish_ ();
 
  return 0;
}