Subversion Repositories scarts

// natObject.cc - Implementation of the Object class.

/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005  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 <platform.h>

#include <string.h>

#pragma implementation "Object.h"

#include <gcj/cni.h>

#include <jvm.h>

#include <java/lang/Object.h>

#include <java-threads.h>

#include <java-signal.h>

#include <java/lang/CloneNotSupportedException.h>

#include <java/lang/IllegalArgumentException.h>

#include <java/lang/IllegalMonitorStateException.h>

#include <java/lang/InterruptedException.h>

#include <java/lang/NullPointerException.h>

#include <java/lang/Class.h>

#include <java/lang/Cloneable.h>

#include <java/lang/Thread.h>

#ifdef LOCK_DEBUG

#  include <stdio.h>

#endif

using namespace java::lang;

// This is used to represent synchronization information.

struct _Jv_SyncInfo

{

#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy)

  // We only need to keep track of initialization state if we can

  // possibly finalize this object.

  bool init;

#endif

  _Jv_ConditionVariable_t condition;

  _Jv_Mutex_t mutex;

};

jclass

java::lang::Object::getClass (void)

{

  _Jv_VTable **dt = (_Jv_VTable **) this;

  return (*dt)->clas;

}

jint

java::lang::Object::hashCode (void)

{

  return _Jv_HashCode (this);

}

jobject

java::lang::Object::clone (void)

{

  jclass klass = getClass ();

  jobject r;

  jint size;

  // We also clone arrays here.  If we put the array code into

  // __JArray, then we'd have to figure out a way to find the array

  // vtbl when creating a new array class.  This is easier, if uglier.

  if (klass->isArray())

    {

      __JArray *array = (__JArray *) this;

      jclass comp = getClass()->getComponentType();

      jint eltsize;

      if (comp->isPrimitive())

        {

          r = _Jv_NewPrimArray (comp, array->length);

          eltsize = comp->size();

        }

      else

        {

          r = _Jv_NewObjectArray (array->length, comp, NULL);

          eltsize = sizeof (jobject);

        }

      // We can't use sizeof on __JArray because we must account for

      // alignment of the element type.

      size = (_Jv_GetArrayElementFromElementType (array, comp) - (char *) array

              + array->length * eltsize);

    }

  else

    {

      if (! java::lang::Cloneable::class$.isAssignableFrom(klass))

        throw new CloneNotSupportedException;

      size = klass->size();

      r = _Jv_AllocObject (klass);

    }

  memcpy ((void *) r, (void *) this, size);

#ifndef JV_HASH_SYNCHRONIZATION

  // Guarantee that the locks associated to the two objects are

  // distinct.

  r->sync_info = NULL;

#endif

  return r;

}

void

_Jv_FinalizeObject (jobject obj)

{

  // Ignore exceptions.  From section 12.6 of the Java Language Spec.

  try

    {

      obj->finalize ();

    }

  catch (java::lang::Throwable *t)

    {

      // Ignore.

    }

}

//

// Synchronization code.

//

#ifndef JV_HASH_SYNCHRONIZATION

// This global is used to make sure that only one thread sets an

// object's `sync_info' field.

static _Jv_Mutex_t sync_mutex;

// This macro is used to see if synchronization initialization is

// needed.

#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy)

#  define INIT_NEEDED(Obj) (! (Obj)->sync_info \

                            || ! ((_Jv_SyncInfo *) ((Obj)->sync_info))->init)

#else

#  define INIT_NEEDED(Obj) (! (Obj)->sync_info)

#endif

#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy)

// If we have to run a destructor for a sync_info member, then this

// function is registered as a finalizer for the sync_info.

static void

finalize_sync_info (jobject obj)

{

  _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj;

#if defined (_Jv_HaveCondDestroy)

  _Jv_CondDestroy (&si->condition);

#endif

#if defined (_Jv_HaveMutexDestroy)

  _Jv_MutexDestroy (&si->mutex);

#endif

  si->init = false;

}

#endif

// This is called to initialize the sync_info element of an object.

void

java::lang::Object::sync_init (void)

{

  _Jv_MutexLock (&sync_mutex);

  // Check again to see if initialization is needed now that we have

  // the lock.

  if (INIT_NEEDED (this))

    {

      // We assume there are no pointers in the sync_info

      // representation.

      _Jv_SyncInfo *si;

      // We always create a new sync_info, even if there is already

      // one available.  Any given object can only be finalized once.

      // If we get here and sync_info is not null, then it has already

      // been finalized.  So if we just reinitialize the old one,

      // we'll never be able to (re-)destroy the mutex and/or

      // condition variable.

      si = (_Jv_SyncInfo *) _Jv_AllocBytes (sizeof (_Jv_SyncInfo));

      _Jv_MutexInit (&si->mutex);

      _Jv_CondInit (&si->condition);

#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy)

      // Register a finalizer.

      si->init = true;

      _Jv_RegisterFinalizer (si, finalize_sync_info);

#endif

      sync_info = (jobject) si;

    }

  _Jv_MutexUnlock (&sync_mutex);

}

void

java::lang::Object::notify (void)

{

  if (__builtin_expect (INIT_NEEDED (this), false))

    sync_init ();

  _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info;

  if (__builtin_expect (_Jv_CondNotify (&si->condition, &si->mutex), false))

    throw new IllegalMonitorStateException(JvNewStringLatin1

                                           ("current thread not owner"));

}

void

java::lang::Object::notifyAll (void)

{

  if (__builtin_expect (INIT_NEEDED (this), false))

    sync_init ();

  _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info;

  if (__builtin_expect (_Jv_CondNotifyAll (&si->condition, &si->mutex), false))

    throw new IllegalMonitorStateException(JvNewStringLatin1

                                           ("current thread not owner"));

}

void

java::lang::Object::wait (jlong timeout, jint nanos)

{

  if (__builtin_expect (INIT_NEEDED (this), false))

    sync_init ();

  if (__builtin_expect (timeout < 0 || nanos < 0 || nanos > 999999, false))

    throw new IllegalArgumentException;

  _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info;

  switch (_Jv_CondWait (&si->condition, &si->mutex, timeout, nanos))

    {

      case _JV_NOT_OWNER:

        throw new IllegalMonitorStateException (JvNewStringLatin1

                                                ("current thread not owner"));

      case _JV_INTERRUPTED:

        if (Thread::interrupted ())

          throw new InterruptedException;

    }

}

//

// Some runtime code.

//

// This function is called at system startup to initialize the

// `sync_mutex'.

void

_Jv_InitializeSyncMutex (void)

{

  _Jv_MutexInit (&sync_mutex);

}

void

_Jv_MonitorEnter (jobject obj)

{

#ifndef HANDLE_SEGV

  if (__builtin_expect (! obj, false))

    throw new java::lang::NullPointerException;

#endif

  if (__builtin_expect (INIT_NEEDED (obj), false))

    obj->sync_init ();

  _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info;

  _Jv_MutexLock (&si->mutex);

  // FIXME: In the Windows case, this can return a nonzero error code.

  // We should turn that into some exception ...

}

void

_Jv_MonitorExit (jobject obj)

{

  JvAssert (obj);

  JvAssert (! INIT_NEEDED (obj));

  _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info;

  if (__builtin_expect (_Jv_MutexUnlock (&si->mutex), false))

    throw new java::lang::IllegalMonitorStateException;

}

bool

_Jv_ObjectCheckMonitor (jobject obj)

{

  if (__builtin_expect (INIT_NEEDED (obj), false))

    obj->sync_init ();

  _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info;

  return _Jv_MutexCheckMonitor (&si->mutex);

}

#else /* JV_HASH_SYNCHRONIZATION */

// FIXME: We shouldn't be calling GC_register_finalizer directly.

#ifndef HAVE_BOEHM_GC

# error Hash synchronization currently requires boehm-gc

// That's actually a bit of a lie: It should also work with the null GC,

// probably even better than the alternative.

// To really support alternate GCs here, we would need to widen the

// interface to finalization, since we sometimes have to register a

// second finalizer for an object that already has one.

// We might also want to move the GC interface to a .h file, since

// the number of procedure call levels involved in some of these

// operations is already ridiculous, and would become worse if we

// went through the proper intermediaries.

#else

# ifdef LIBGCJ_GC_DEBUG

#   define GC_DEBUG

# endif

# include "gc.h"

#endif

// What follows currenly assumes a Linux-like platform.

// Some of it specifically assumes X86 or IA64 Linux, though that

// should be easily fixable.

// A Java monitor implemention based on a table of locks.

// Each entry in the table describes

// locks held for objects that hash to that location.

// This started out as a reimplementation of the technique used in SGIs JVM,

// for which we obtained permission from SGI.

// But in fact, this ended up quite different, though some ideas are

// still shared with the original.

// It was also influenced by some of the published IBM work,

// though it also differs in many ways from that.

// We could speed this up if we had a way to atomically update

// an entire cache entry, i.e. 2 contiguous words of memory.

// That would usually be the case with a 32 bit ABI on a 64 bit processor.

// But we don't currently go out of our way to target those.

// I don't know how to do much better with a N bit ABI on a processor

// that can atomically update only N bits at a time.

// Author: Hans-J. Boehm  (Hans_Boehm@hp.com, boehm@acm.org)

#include <limits.h>

#include <unistd.h>     // for usleep, sysconf.

#include <gcj/javaprims.h>

#include <sysdep/locks.h>

#include <java/lang/Thread.h>

// Try to determine whether we are on a multiprocessor, i.e. whether

// spinning may be profitable.

// This should really use a suitable autoconf macro.

// False is the conservative answer, though the right one is much better.

static bool

is_mp()

{

#ifdef _SC_NPROCESSORS_ONLN

  long nprocs = sysconf(_SC_NPROCESSORS_ONLN);

  return (nprocs > 1);

#else

  return false;

#endif

}

// A call to keep_live(p) forces p to be accessible to the GC

// at this point.

inline static void

keep_live(obj_addr_t p)

{

    __asm__ __volatile__("" : : "rm"(p) : "memory");

}

// Each hash table entry holds a single preallocated "lightweight" lock.

// In addition, it holds a chain of "heavyweight" locks.  Lightweight

// locks do not support Object.wait(), and are converted to heavyweight

// status in response to contention.  Unlike the SGI scheme, both

// ligtweight and heavyweight locks in one hash entry can be simultaneously

// in use.  (The SGI scheme requires that we be able to acquire a heavyweight

// lock on behalf of another thread, and can thus convert a lock we don't

// hold to heavyweight status.  Here we don't insist on that, and thus

// let the original holder of the lighweight lock keep it.)

struct heavy_lock {

  void * reserved_for_gc;

  struct heavy_lock *next;      // Hash chain link.

                                // Traced by GC.

  void * old_client_data;       // The only other field traced by GC.

  GC_finalization_proc old_finalization_proc;

  obj_addr_t address;           // Object to which this lock corresponds.

                                // Should not be traced by GC.

                                // Cleared as heavy_lock is destroyed.

                                // Together with the rest of the heavy lock

                                // chain, this is protected by the lock

                                // bit in the hash table entry to which

                                // the chain is attached.

  _Jv_SyncInfo si;

  // The remaining fields save prior finalization info for

  // the object, which we needed to replace in order to arrange

  // for cleanup of the lock structure.

};

#ifdef LOCK_DEBUG

void

print_hl_list(heavy_lock *hl)

{

    heavy_lock *p = hl;

    for (; 0 != p; p = p->next)

      fprintf (stderr, "(hl = %p, addr = %p)", p, (void *)(p -> address));

}

#endif /* LOCK_DEBUG */

#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy)

// If we have to run a destructor for a sync_info member, then this

// function could be registered as a finalizer for the sync_info.

// In fact, we now only invoke it explicitly.

static inline void

heavy_lock_finalization_proc (heavy_lock *hl)

{

#if defined (_Jv_HaveCondDestroy)

  _Jv_CondDestroy (&hl->si.condition);

#endif

#if defined (_Jv_HaveMutexDestroy)

  _Jv_MutexDestroy (&hl->si.mutex);

#endif

  hl->si.init = false;

}

#endif /* defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) */

// We convert the lock back to lightweight status when

// we exit, so that a single contention episode doesn't doom the lock

// forever.  But we also need to make sure that lock structures for dead

// objects are eventually reclaimed.  We do that in a an additional

// finalizer on the underlying object.

// Note that if the corresponding object is dead, it is safe to drop

// the heavy_lock structure from its list.  It is not necessarily

// safe to deallocate it, since the unlock code could still be running.

struct hash_entry {

  volatile obj_addr_t address;  // Address of object for which lightweight

                                // k is held.

                                // We assume the 3 low order bits are zero.

                                // With the Boehm collector and bitmap

                                // allocation, objects of size 4 bytes are

                                // broken anyway.  Thus this is primarily

                                // a constraint on statically allocated

                                // objects used for synchronization.

                                // This allows us to use the low order

                                // bits as follows:

#   define LOCKED       1       // This hash entry is locked, and its

                                // state may be invalid.

                                // The lock protects both the hash_entry

                                // itself (except for the light_count

                                // and light_thr_id fields, which

                                // are protected by the lightweight

                                // lock itself), and any heavy_monitor

                                // structures attached to it.

#   define HEAVY        2       // Heavyweight locks associated with this

                                // hash entry may be held.

                                // The lightweight entry is still valid,

                                // if the leading bits of the address

                                // field are nonzero.

                                // If the LOCKED bit is clear, then this is

                                // set exactly when heavy_count is > 0 .

                                // Stored redundantly so a single

                                // compare-and-swap works in the easy case.

                                // If HEAVY is not set, it is safe to use

                                // an available lightweight lock entry

                                // without checking if there is an existing

                                // heavyweight lock for the same object.

                                // (There may be one, but it won't be held

                                // or waited for.)

#   define REQUEST_CONVERSION 4 // The lightweight lock is held.  But

                                // one or more other threads have tried

                                // to acquire the lock, and hence request

                                // conversion to heavyweight status.

                                // The heavyweight lock is already allocated.

                                // Threads requesting conversion are

                                // waiting on the condition variable associated

                                // with the heavyweight lock.

                                // Not used for conversion due to

                                // Object.wait() calls.

#   define FLAGS (LOCKED | HEAVY | REQUEST_CONVERSION)

  volatile _Jv_ThreadId_t light_thr_id;

                                // Thr_id of holder of lightweight lock.

                                // Only updated by lightweight lock holder.

                                // Must be recognizably invalid if the

                                // lightweight lock is not held.

#   define INVALID_THREAD_ID 0  // Works for Linux?

                                // If zero doesn't work, we have to

                                // initialize lock table.

  volatile unsigned short light_count;

                                // Number of times the lightweight lock

                                // is held minus one.  Zero if lightweight

                                // lock is not held.  Only updated by

                                // lightweight lock holder or, in one

                                // case, while holding the LOCKED bit in

                                // a state in which there can be no

                                // lightweight lock holder.

  unsigned short heavy_count;   // Total number of times heavyweight locks

                                // associated with this hash entry are held

                                // or waiting to be acquired.

                                // Threads in wait() are included eventhough

                                // they have temporarily released the lock.

                                // Protected by LOCKED bit.

                                // Threads requesting conversion to heavyweight

                                // status are also included.

  struct heavy_lock * heavy_locks;

                                // Chain of heavy locks.  Protected

                                // by lockbit for he.  Locks may

                                // remain allocated here even if HEAVY

                                // is not set and heavy_count is 0.

                                // If a lightweight and heavyweight lock

                                // correspond to the same address, the

                                // lightweight lock is the right one.

};

#ifndef JV_SYNC_TABLE_SZ

# define JV_SYNC_TABLE_SZ 2048  // Must be power of 2.

#endif

hash_entry light_locks[JV_SYNC_TABLE_SZ];

#define JV_SYNC_HASH(p) (((long)p ^ ((long)p >> 10)) & (JV_SYNC_TABLE_SZ-1))

// Note that the light_locks table is scanned conservatively by the

// collector.  It is essential the the heavy_locks field is scanned.

// Currently the address field may or may not cause the associated object

// to be retained, depending on whether flag bits are set.

// This means that we can conceivable get an unexpected deadlock if

// 1) Object at address A is locked.

// 2) The client drops A without unlocking it.

// 3) Flag bits in the address entry are set, so the collector reclaims

//    the object at A.

// 4) A is reallocated, and an attempt is made to lock the result.

// This could be fixed by scanning light_locks in a more customized

// manner that ignores the flag bits.  But it can only happen with hand

// generated semi-illegal .class files, and then it doesn't present a

// security hole.

#ifdef LOCK_DEBUG

  void print_he(hash_entry *he)

  {

     fprintf(stderr, "lock hash entry = %p, index = %d, address = 0x%lx\n"

                     "\tlight_thr_id = 0x%lx, light_count = %d, "

                     "heavy_count = %d\n\theavy_locks:", he,

                     he - light_locks, (unsigned long)(he -> address),

                     (unsigned long)(he -> light_thr_id),

                     he -> light_count, he -> heavy_count);

     print_hl_list(he -> heavy_locks);

     fprintf(stderr, "\n");

  }

#endif /* LOCK_DEBUG */

#ifdef LOCK_LOG

  // Log locking operations.  For debugging only.

  // Logging is intended to be as unintrusive as possible.

  // Log calls are made after an operation completes, and hence

  // may not completely reflect actual synchronization ordering.

  // The choice of events to log is currently a bit haphazard.

  // The intent is that if we have to track down any other bugs

  // inthis code, we extend the logging as appropriate.

  typedef enum

  {

    ACQ_LIGHT, ACQ_LIGHT2, ACQ_HEAVY, ACQ_HEAVY2, PROMOTE, REL_LIGHT,

    REL_HEAVY, REQ_CONV, PROMOTE2, WAIT_START, WAIT_END, NOTIFY, NOTIFY_ALL

  } event_type;

  struct lock_history

  {

    event_type tp;

    obj_addr_t addr;  // Often includes flags.

    _Jv_ThreadId_t thr;

  };

  const int LOG_SIZE = 128;     // Power of 2.

  lock_history lock_log[LOG_SIZE];

  volatile obj_addr_t log_next = 0;

                           // Next location in lock_log.

                           // Really an int, but we need compare_and_swap.

  static void add_log_entry(event_type t, obj_addr_t a, _Jv_ThreadId_t th)

  {

    obj_addr_t my_entry;

    obj_addr_t next_entry;

    do

      {

        my_entry = log_next;

        next_entry = ((my_entry + 1) & (LOG_SIZE - 1));

      }

    while (!compare_and_swap(&log_next, my_entry, next_entry));

    lock_log[my_entry].tp = t;

    lock_log[my_entry].addr = a;

    lock_log[my_entry].thr = th;

  }

# define LOG(t, a, th) add_log_entry(t, a, th)

#else /* !LOCK_LOG */

# define LOG(t, a, th)

#endif

static bool mp = false; // Known multiprocesssor.

// Wait for roughly 2^n units, touching as little memory as possible.

static void

spin(unsigned n)

{

  const unsigned MP_SPINS = 10;

  const unsigned YIELDS = 4;

  const unsigned SPINS_PER_UNIT = 30;

  const unsigned MIN_SLEEP_USECS = 2001; // Shorter times spin under Linux.

  const unsigned MAX_SLEEP_USECS = 200000;

  static unsigned spin_limit = 0;

  static unsigned yield_limit = YIELDS;

  static bool spin_initialized = false;

  if (!spin_initialized)

    {

      mp = is_mp();

      if (mp)

        {

          spin_limit = MP_SPINS;

          yield_limit = MP_SPINS + YIELDS;

        }

      spin_initialized = true;

    }

  if (n < spin_limit)

    {

      unsigned i = SPINS_PER_UNIT << n;

      for (; i > 0; --i)

        __asm__ __volatile__("");

    }

  else if (n < yield_limit)

    {

      _Jv_ThreadYield();

    }

  else

    {

      unsigned duration = MIN_SLEEP_USECS << (n - yield_limit);

      if (n >= 15 + yield_limit || duration > MAX_SLEEP_USECS)

        duration = MAX_SLEEP_USECS;

      _Jv_platform_usleep(duration);

    }

}

// Wait for a hash entry to become unlocked.

static void

wait_unlocked (hash_entry *he)

{

  unsigned i = 0;

  while (he -> address & LOCKED)

    spin (i++);

}

// Return the heavy lock for addr if it was already allocated.

// The client passes in the appropriate hash_entry.

// We hold the lock for he.

static inline heavy_lock *

find_heavy (obj_addr_t addr, hash_entry *he)

{

  heavy_lock *hl = he -> heavy_locks;

  while (hl != 0 && hl -> address != addr) hl = hl -> next;

  return hl;

}

// Unlink the heavy lock for the given address from its hash table chain.

// Dies miserably and conspicuously if it's not there, since that should

// be impossible.

static inline void

unlink_heavy (obj_addr_t addr, hash_entry *he)

{

  heavy_lock **currentp = &(he -> heavy_locks);

  while ((*currentp) -> address != addr)

    currentp = &((*currentp) -> next);

  *currentp = (*currentp) -> next;

}

// Finalization procedure for objects that have associated heavy-weight

// locks.  This may replace the real finalization procedure.

static void

heavy_lock_obj_finalization_proc (void *obj, void *cd)

{

  heavy_lock *hl = (heavy_lock *)cd;

// This only addresses misalignment of statics, not heap objects.  It

// works only because registering statics for finalization is a noop,

// no matter what the least significant bits are.

#ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS

  obj_addr_t addr = (obj_addr_t)obj & ~((obj_addr_t)0x7);

#else

  obj_addr_t addr = (obj_addr_t)obj;

#endif

  hash_entry *he = light_locks + JV_SYNC_HASH(addr);

  obj_addr_t he_address = (he -> address & ~LOCKED);

  // Acquire lock bit immediately.  It's possible that the hl was already

  // destroyed while we were waiting for the finalizer to run.  If it

  // was, the address field was set to zero.  The address filed access is

  // protected by the lock bit to ensure that we do this exactly once.

  // The lock bit also protects updates to the objects finalizer.

  while (!compare_and_swap(&(he -> address), he_address, he_address|LOCKED ))

    {

      // Hash table entry is currently locked.  We can't safely 

      // touch the list of heavy locks.  

      wait_unlocked(he);

      he_address = (he -> address & ~LOCKED);

    }

  if (0 == hl -> address)

    {

      // remove_all_heavy destroyed hl, and took care of the real finalizer.

      release_set(&(he -> address), he_address);

      return;

    }

  JvAssert(hl -> address == addr);

  GC_finalization_proc old_finalization_proc = hl -> old_finalization_proc;

  if (old_finalization_proc != 0)

    {

      // We still need to run a real finalizer.  In an idealized

      // world, in which people write thread-safe finalizers, that is

      // likely to require synchronization.  Thus we reregister

      // ourselves as the only finalizer, and simply run the real one.

      // Thus we don't clean up the lock yet, but we're likely to do so

      // on the next GC cycle.

      // It's OK if remove_all_heavy actually destroys the heavy lock,

      // since we've updated old_finalization_proc, and thus the user's

      // finalizer won't be rerun.

      void * old_client_data = hl -> old_client_data;

      hl -> old_finalization_proc = 0;

      hl -> old_client_data = 0;

#     ifdef HAVE_BOEHM_GC

        GC_REGISTER_FINALIZER_NO_ORDER(obj, heavy_lock_obj_finalization_proc, cd, 0, 0);

#     endif

      release_set(&(he -> address), he_address);