source: trunk/third/gcc/libjava/resolve.cc @ 18474

// resolve.cc - Code for linking and resolving classes and pool entries.

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

/* Author: Kresten Krab Thorup <krab@gnu.org>  */

#include <config.h>

#include <java-interp.h>

#include <jvm.h>
#include <gcj/cni.h>
#include <string.h>
#include <java-cpool.h>
#include <java/lang/Class.h>
#include <java/lang/String.h>
#include <java/lang/Thread.h>
#include <java/lang/InternalError.h>
#include <java/lang/VirtualMachineError.h>
#include <java/lang/NoSuchFieldError.h>
#include <java/lang/NoSuchMethodError.h>
#include <java/lang/ClassFormatError.h>
#include <java/lang/IllegalAccessError.h>
#include <java/lang/AbstractMethodError.h>
#include <java/lang/ClassNotFoundException.h>
#include <java/lang/IncompatibleClassChangeError.h>
#include <java/lang/reflect/Modifier.h>

using namespace gcj;

void
_Jv_ResolveField (_Jv_Field *field, java::lang::ClassLoader *loader)
{
  if (! field->isResolved ())
    {
      _Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type;
      field->type = _Jv_FindClassFromSignature (sig->data, loader);
      field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
    }
}

#ifdef INTERPRETER

static void throw_internal_error (char *msg)
        __attribute__ ((__noreturn__));
static void throw_class_format_error (jstring msg)
        __attribute__ ((__noreturn__));
static void throw_class_format_error (char *msg)
        __attribute__ ((__noreturn__));

// Exceptional return values for _Jv_DetermineVTableIndex
#define METHOD_NOT_THERE (-2)
#define METHOD_INACCESSIBLE (-1)

static int get_alignment_from_class (jclass);

static _Jv_ResolvedMethod* 
_Jv_BuildResolvedMethod (_Jv_Method*,
                         jclass,
                         jboolean,
                         jint);


static void throw_incompatible_class_change_error (jstring msg)
{
  throw new java::lang::IncompatibleClassChangeError (msg);
}

_Jv_word
_Jv_ResolvePoolEntry (jclass klass, int index)
{
  using namespace java::lang::reflect;

  _Jv_Constants *pool = &klass->constants;

  if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0)
    return pool->data[index];

  switch (pool->tags[index]) {
  case JV_CONSTANT_Class:
    {
      _Jv_Utf8Const *name = pool->data[index].utf8;

      jclass found;
      if (name->data[0] == '[')
        found = _Jv_FindClassFromSignature (&name->data[0],
                                            klass->loader);
      else
        found = _Jv_FindClass (name, klass->loader);

      if (! found)
        {
          jstring str = _Jv_NewStringUTF (name->data);
          throw new java::lang::ClassNotFoundException (str);
        }

      if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC
          || (_Jv_ClassNameSamePackage (found->name,
                                        klass->name)))
        {
          pool->data[index].clazz = found;
          pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
        }
      else
        {
          throw new java::lang::IllegalAccessError (found->getName());
        }
    }
    break;

  case JV_CONSTANT_String:
    {
      jstring str;
      str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
      pool->data[index].o = str;
      pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
    }
    break;


  case JV_CONSTANT_Fieldref:
    {
      _Jv_ushort class_index, name_and_type_index;
      _Jv_loadIndexes (&pool->data[index],
                       class_index,
                       name_and_type_index);
      jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz;

      if (owner != klass)
        _Jv_InitClass (owner);

      _Jv_ushort name_index, type_index;
      _Jv_loadIndexes (&pool->data[name_and_type_index],
                       name_index,
                       type_index);

      _Jv_Utf8Const *field_name = pool->data[name_index].utf8;
      _Jv_Utf8Const *field_type_name = pool->data[type_index].utf8;

      // FIXME: The implementation of this function
      // (_Jv_FindClassFromSignature) will generate an instance of
      // _Jv_Utf8Const for each call if the field type is a class name
      // (Lxx.yy.Z;).  This may be too expensive to do for each and
      // every fieldref being resolved.  For now, we fix the problem by
      // only doing it when we have a loader different from the class
      // declaring the field.

      jclass field_type = 0;

      if (owner->loader != klass->loader)
        field_type = _Jv_FindClassFromSignature (field_type_name->data,
                                                 klass->loader);
      
      _Jv_Field* the_field = 0;

      for (jclass cls = owner; cls != 0; cls = cls->getSuperclass ())
        {
          for (int i = 0;  i < cls->field_count;  i++)
            {
              _Jv_Field *field = &cls->fields[i];
              if (! _Jv_equalUtf8Consts (field->name, field_name))
                continue;

              // now, check field access. 

              if (   (cls == klass)
                  || ((field->flags & Modifier::PUBLIC) != 0)
                  || (((field->flags & Modifier::PROTECTED) != 0)
                      && cls->isAssignableFrom (klass))
                  || (((field->flags & Modifier::PRIVATE) == 0)
                      && _Jv_ClassNameSamePackage (cls->name,
                                                   klass->name)))
                {
                  /* resove the field using the class' own loader
                     if necessary */

                  if (!field->isResolved ())
                    _Jv_ResolveField (field, cls->loader);

                  if (field_type != 0 && field->type != field_type)
                    throw new java::lang::LinkageError
                      (JvNewStringLatin1 
                       ("field type mismatch with different loaders"));

                  the_field = field;
                  goto end_of_field_search;
                }
              else
                {
                  throw new java::lang::IllegalAccessError;
                }
            }
        }

    end_of_field_search:
      if (the_field == 0)
        {
          jstring msg = JvNewStringLatin1 ("field ");
          msg = msg->concat (owner->getName ());
          msg = msg->concat (JvNewStringLatin1("."));
          msg = msg->concat (_Jv_NewStringUTF (field_name->data));
          msg = msg->concat (JvNewStringLatin1(" was not found."));
          throw_incompatible_class_change_error (msg);
        }

      pool->data[index].field = the_field;
      pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
    }
    break;

  case JV_CONSTANT_Methodref:
  case JV_CONSTANT_InterfaceMethodref:
    {
      _Jv_ushort class_index, name_and_type_index;
      _Jv_loadIndexes (&pool->data[index],
                       class_index,
                       name_and_type_index);
      jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz;

      if (owner != klass)
        _Jv_InitClass (owner);

      _Jv_ushort name_index, type_index;
      _Jv_loadIndexes (&pool->data[name_and_type_index],
                       name_index,
                       type_index);

      _Jv_Utf8Const *method_name = pool->data[name_index].utf8;
      _Jv_Utf8Const *method_signature = pool->data[type_index].utf8;

      int vtable_index = -1;
      _Jv_Method *the_method = 0;
      jclass found_class = 0;

      // First search the class itself.
      the_method = _Jv_SearchMethodInClass (owner, klass, 
                   method_name, method_signature);

      if (the_method != 0)
        {
          found_class = owner;
          goto end_of_method_search;
        }

      // If we are resolving an interface method, search the interface's 
      // superinterfaces (A superinterface is not an interface's superclass - 
      // a superinterface is implemented by the interface).
      if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref)
        {
          _Jv_ifaces ifaces;
          ifaces.count = 0;
          ifaces.len = 4;
          ifaces.list = (jclass *) _Jv_Malloc (ifaces.len * sizeof (jclass *));

          _Jv_GetInterfaces (owner, &ifaces);     
          
          for (int i=0; i < ifaces.count; i++)
            {
              jclass cls = ifaces.list[i];
              the_method = _Jv_SearchMethodInClass (cls, klass, method_name, 
                                                    method_signature);
              if (the_method != 0)
                {
                  found_class = cls;
                  break;
                }
            }
          
          _Jv_Free (ifaces.list);
          
          if (the_method != 0)
            goto end_of_method_search;
        }

      // Finally, search superclasses. 
      for (jclass cls = owner->getSuperclass (); cls != 0; 
           cls = cls->getSuperclass ())
        {
          the_method = _Jv_SearchMethodInClass (cls, klass, 
                       method_name, method_signature);
          if (the_method != 0)
            {
              found_class = cls;
              break;
            }
        }

    end_of_method_search:
    
      // FIXME: if (cls->loader != klass->loader), then we
      // must actually check that the types of arguments
      // correspond.  That is, for each argument type, and
      // the return type, doing _Jv_FindClassFromSignature
      // with either loader should produce the same result,
      // i.e., exactly the same jclass object. JVMS 5.4.3.3    
    
      if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref)
        vtable_index = -1;
      else
        vtable_index = _Jv_DetermineVTableIndex
          (found_class, method_name, method_signature);

      if (vtable_index == METHOD_NOT_THERE)
        throw_incompatible_class_change_error
          (JvNewStringLatin1 ("method not found"));

      if (the_method == 0)
        {
          jstring msg = JvNewStringLatin1 ("method ");
          msg = msg->concat (owner->getName ());
          msg = msg->concat (JvNewStringLatin1("."));
          msg = msg->concat (_Jv_NewStringUTF (method_name->data));
          msg = msg->concat (JvNewStringLatin1(" was not found."));
          throw new java::lang::NoSuchMethodError (msg);
        }
      
      pool->data[index].rmethod = 
        _Jv_BuildResolvedMethod(the_method,
                                found_class,
                                (the_method->accflags & Modifier::STATIC) != 0,
                                vtable_index);
      pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
    }
    break;

  }

  return pool->data[index];
}

// Find a method declared in the cls that is referenced from klass and
// perform access checks.
_Jv_Method *
_Jv_SearchMethodInClass (jclass cls, jclass klass, 
                         _Jv_Utf8Const *method_name, 
                         _Jv_Utf8Const *method_signature)
{
  using namespace java::lang::reflect;

  for (int i = 0;  i < cls->method_count;  i++)
    {
      _Jv_Method *method = &cls->methods[i];
      if (   (!_Jv_equalUtf8Consts (method->name,
                                    method_name))
          || (!_Jv_equalUtf8Consts (method->signature,
                                    method_signature)))
        continue;

      if (cls == klass 
          || ((method->accflags & Modifier::PUBLIC) != 0)
          || (((method->accflags & Modifier::PROTECTED) != 0)
              && cls->isAssignableFrom (klass))
          || (((method->accflags & Modifier::PRIVATE) == 0)
              && _Jv_ClassNameSamePackage (cls->name,
                                           klass->name)))
        {
          return method;
        }
      else
        {
          throw new java::lang::IllegalAccessError;
        }
    }
  return 0;
}

/** FIXME: this is a terribly inefficient algorithm!  It would improve
    things if compiled classes to know vtable offset, and _Jv_Method had
    a field for this.

    Returns METHOD_NOT_THERE if this class does not declare the given method.
    Returns METHOD_INACCESSIBLE if the given method does not appear in the
                vtable, i.e., it is static, private, final or a constructor.
    Otherwise, returns the vtable index.  */
int 
_Jv_DetermineVTableIndex (jclass klass,
                          _Jv_Utf8Const *name,
                          _Jv_Utf8Const *signature)
{
  using namespace java::lang::reflect;

  jclass super_class = klass->getSuperclass ();

  if (super_class != NULL)
    {
      int prev = _Jv_DetermineVTableIndex (super_class,
                                           name,
                                           signature);
      if (prev != METHOD_NOT_THERE)
        return prev;
    }

  /* at this point, we know that the super-class does not declare
   * the method.  Otherwise, the above call would have found it, and
   * determined the result of this function (-1 or some positive
   * number).
   */

  _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);

  /* now, if we do not declare this method, return zero */
  if (meth == NULL)
    return METHOD_NOT_THERE;

  /* so now, we know not only that the super class does not declare the
   * method, but we do!  So, this is a first declaration of the method. */

  /* now, the checks for things that are declared in this class, but do
   * not go into the vtable.  There are three cases.  
   * 1) the method is static, private or final
   * 2) the class itself is final, or
   * 3) it is the method <init>
   */

  if ((meth->accflags & (Modifier::STATIC
                         | Modifier::PRIVATE
                         | Modifier::FINAL)) != 0
      || (klass->accflags & Modifier::FINAL) != 0
      || _Jv_equalUtf8Consts (name, init_name))
    return METHOD_INACCESSIBLE;

  /* reaching this point, we know for sure, that the method in question
   * will be in the vtable.  The question is where. */

  /* the base offset, is where we will start assigning vtable
   * indexes for this class.  It is 0 for base classes
   * and for non-base classes it is the
   * number of entries in the super class' vtable. */

  int base_offset;
  if (super_class == 0)
    base_offset = 0;
  else
    base_offset = super_class->vtable_method_count;

  /* we will consider methods 0..this_method_index-1.  And for each one,
   * determine if it is new (i.e., if it appears in the super class),
   * and if it should go in the vtable.  If so, increment base_offset */

  int this_method_index = meth - (&klass->methods[0]);

  for (int i = 0; i < this_method_index; i++)
    {
      _Jv_Method *m = &klass->methods[i];

      /* fist some checks for things that surely do not go in the
       * vtable */

      if ((m->accflags & (Modifier::STATIC | Modifier::PRIVATE)) != 0)
        continue;
      if (_Jv_equalUtf8Consts (m->name, init_name))
        continue;
      
      /* Then, we need to know if this method appears in the
         superclass. (This is where this function gets expensive) */
      _Jv_Method *sm = _Jv_LookupDeclaredMethod (super_class,
                                                 m->name,
                                                 m->signature);
      
      /* if it was somehow declared in the superclass, skip this */
      if (sm != NULL)
        continue;

      /* but if it is final, and not declared in the super class,
       * then we also skip it */
      if ((m->accflags & Modifier::FINAL) != 0)
        continue;

      /* finally, we can assign the index of this method */
      /* m->vtable_index = base_offset */
      base_offset += 1;
    }

  return base_offset;
}

/* this is installed in place of abstract methods */
static void
_Jv_abstractMethodError ()
{
  throw new java::lang::AbstractMethodError;
}

void 
_Jv_PrepareClass(jclass klass)
{
  using namespace java::lang::reflect;

 /*
  * The job of this function is to: 1) assign storage to fields, and 2)
  * build the vtable.  static fields are assigned real memory, instance
  * fields are assigned offsets.
  *
  * NOTE: we have a contract with the garbage collector here.  Static
  * reference fields must not be resolved, until after they have storage
  * assigned which is the check used by the collector to see if it
  * should indirect the static field reference and mark the object
  * pointed to. 
  *
  * Most fields are resolved lazily (i.e. have their class-type
  * assigned) when they are accessed the first time by calling as part
  * of _Jv_ResolveField, which is allways called after _Jv_PrepareClass.
  * Static fields with initializers are resolved as part of this
  * function, as are fields with primitive types.
  */

  if (! _Jv_IsInterpretedClass (klass))
    return;

  if (klass->state >= JV_STATE_PREPARED)
    return;

  // make sure super-class is linked.  This involves taking a lock on
  // the super class, so we use the Java method resolveClass, which will
  // unlock it properly, should an exception happen.

  java::lang::ClassLoader::resolveClass0 (klass->superclass);

  _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;

  /************ PART ONE: OBJECT LAYOUT ***************/

  int instance_size;
  int static_size;

  // java.lang.Object is never interpreted!
  instance_size = clz->superclass->size ();
  static_size   = 0;

  for (int i = 0; i < clz->field_count; i++)
    {
      int field_size;
      int field_align;

      _Jv_Field *field = &clz->fields[i];

      if (! field->isRef ())
        {
          // it's safe to resolve the field here, since it's 
          // a primitive class, which does not cause loading to happen.
          _Jv_ResolveField (field, clz->loader);

          field_size = field->type->size ();
          field_align = get_alignment_from_class (field->type);
        }
      else 
        {
          field_size = sizeof (jobject);
          field_align = __alignof__ (jobject);
        }

#ifndef COMPACT_FIELDS
      field->bsize = field_size;
#endif

      if (field->flags & Modifier::STATIC)
        {
          /* this computes an offset into a region we'll allocate 
             shortly, and then add this offset to the start address */

          static_size        = ROUND (static_size, field_align);
          field->u.boffset   = static_size;
          static_size       += field_size;
        }
      else
        {
          instance_size      = ROUND (instance_size, field_align);
          field->u.boffset   = instance_size;
          instance_size     += field_size;
        }
    }

  // set the instance size for the class
  clz->size_in_bytes = instance_size;

  // allocate static memory
  if (static_size != 0)
    {
      char *static_data = (char*)_Jv_AllocBytes (static_size);

      memset (static_data, 0, static_size);

      for (int i = 0; i < clz->field_count; i++)
        {
          _Jv_Field *field = &clz->fields[i];

          if ((field->flags & Modifier::STATIC) != 0)
            {
              field->u.addr  = static_data + field->u.boffset;
                            
              if (clz->field_initializers[i] != 0)
                {
                  _Jv_ResolveField (field, clz->loader);
                  _Jv_InitField (0, clz, i);
                }
            }
        }

      // now we don't need the field_initializers anymore, so let the
      // collector get rid of it!

      clz->field_initializers = 0;
    }

  /************ PART TWO: VTABLE LAYOUT ***************/

  /* preparation: build the vtable stubs (even interfaces can)
     have code -- for static constructors. */
  for (int i = 0; i < clz->method_count; i++)
    {
      _Jv_MethodBase *imeth = clz->interpreted_methods[i];

      if ((clz->methods[i].accflags & Modifier::NATIVE) != 0)
        {
          // You might think we could use a virtual `ncode' method in
          // the _Jv_MethodBase and unify the native and non-native
          // cases.  Well, we can't, because we don't allocate these
          // objects using `new', and thus they don't get a vtable.
          _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth);
          clz->methods[i].ncode = jnim->ncode ();
        }
      else if (imeth != 0)              // it could be abstract
        {
          _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
          _Jv_VerifyMethod (im);
          clz->methods[i].ncode = im->ncode ();
        }
    }

  if (clz->accflags & Modifier::INTERFACE)
    {
      clz->state = JV_STATE_PREPARED;
      clz->notifyAll ();
      return;
    }

  /* Now onto the actual job: vtable layout.  First, count how many new
     methods we have */
  int new_method_count = 0;

  jclass super_class = clz->getSuperclass ();

  if (super_class == 0)
    throw_internal_error ("cannot handle interpreted base classes");

  for (int i = 0; i < clz->method_count; i++)
    {
      _Jv_Method *this_meth = &clz->methods[i];

      if ((this_meth->accflags & (Modifier::STATIC | Modifier::PRIVATE)) != 0
          || _Jv_equalUtf8Consts (this_meth->name, init_name))
        {
          /* skip this, it doesn't go in the vtable */
          continue;
        }
          
      _Jv_Method *orig_meth = _Jv_LookupDeclaredMethod (super_class,
                                                        this_meth->name,
                                                        this_meth->signature);

      if (orig_meth == 0)
        {
          // new methods that are final, also don't go in the vtable
          if ((this_meth->accflags & Modifier::FINAL) != 0)
            continue;

          new_method_count += 1;
          continue;
        }

      if ((orig_meth->accflags & (Modifier::STATIC
                                  | Modifier::PRIVATE
                                  | Modifier::FINAL)) != 0
          || ((orig_meth->accflags & Modifier::ABSTRACT) == 0
              && (this_meth->accflags & Modifier::ABSTRACT) != 0
              && (klass->accflags & Modifier::ABSTRACT) == 0))
        {
          clz->state = JV_STATE_ERROR;
          clz->notifyAll ();
          throw new java::lang::IncompatibleClassChangeError (clz->getName ());
        }

      /* FIXME: At this point, if (loader != super_class->loader), we
       * need to "impose class loader constraints" for the types
       * involved in the signature of this method */
    }
  
  /* determine size */
  int vtable_count = (super_class->vtable_method_count) + new_method_count;
  clz->vtable_method_count = vtable_count;

  /* allocate vtable structure */
  _Jv_VTable *vtable = _Jv_VTable::new_vtable (vtable_count);
  vtable->clas = clz;
  vtable->gc_descr = _Jv_BuildGCDescr(clz);

  {
    jclass effective_superclass = super_class;

    /* If super_class is abstract or an interface it has no vtable.
       We need to find a real one... */
    while (effective_superclass && effective_superclass->vtable == NULL)
      effective_superclass = effective_superclass->superclass;

    /* copy super class' vtable entries. */
    if (effective_superclass && effective_superclass->vtable)
      for (int i = 0; i < effective_superclass->vtable_method_count; ++i)
        vtable->set_method (i, effective_superclass->vtable->get_method (i));
  }

  /* now, install our own vtable entries, reprise... */
  for (int i = 0; i < clz->method_count; i++)
    {
      _Jv_Method *this_meth = &clz->methods[i];

      int index = _Jv_DetermineVTableIndex (clz, 
                                            this_meth->name,
                                            this_meth->signature);

      if (index == METHOD_NOT_THERE)
        throw_internal_error ("method now found in own class");

      if (index != METHOD_INACCESSIBLE)
        {
          if (index > clz->vtable_method_count)
            throw_internal_error ("vtable problem...");

          if (clz->interpreted_methods[i] == 0)
            vtable->set_method(index, (void*)&_Jv_abstractMethodError);
          else
            vtable->set_method(index, this_meth->ncode);
        }
    }

  /* finally, assign the vtable! */
  clz->vtable = vtable;

  /* wooha! we're done. */
  clz->state = JV_STATE_PREPARED;
  clz->notifyAll ();
}

/** Do static initialization for fields with a constant initializer */
void
_Jv_InitField (jobject obj, jclass klass, int index)
{
  using namespace java::lang::reflect;

  if (obj != 0 && klass == 0)
    klass = obj->getClass ();

  if (!_Jv_IsInterpretedClass (klass))
    return;

  _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;

  _Jv_Field * field = (&clz->fields[0]) + index;

  if (index > clz->field_count)
    throw_internal_error ("field out of range");

  int init = clz->field_initializers[index];
  if (init == 0)
    return;

  _Jv_Constants *pool = &clz->constants;
  int tag = pool->tags[init];

  if (! field->isResolved ())
    throw_internal_error ("initializing unresolved field");

  if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
    throw_internal_error ("initializing non-static field with no object");

  void *addr = 0;

  if ((field->flags & Modifier::STATIC) != 0)
    addr = (void*) field->u.addr;
  else
    addr = (void*) (((char*)obj) + field->u.boffset);

  switch (tag)
    {
    case JV_CONSTANT_String:
      {
        _Jv_MonitorEnter (clz);
        jstring str;
        str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
        pool->data[init].string = str;
        pool->tags[init] = JV_CONSTANT_ResolvedString;
        _Jv_MonitorExit (clz);
      }
      /* fall through */

    case JV_CONSTANT_ResolvedString:
      if (! (field->type == &StringClass
             || field->type == &java::lang::Class::class$))
        throw_class_format_error ("string initialiser to non-string field");

      *(jstring*)addr = pool->data[init].string;
      break;

    case JV_CONSTANT_Integer:
      {
        int value = pool->data[init].i;

        if (field->type == JvPrimClass (boolean))
          *(jboolean*)addr = (jboolean)value;
        
        else if (field->type == JvPrimClass (byte))
          *(jbyte*)addr = (jbyte)value;
        
        else if (field->type == JvPrimClass (char))
          *(jchar*)addr = (jchar)value;

        else if (field->type == JvPrimClass (short))
          *(jshort*)addr = (jshort)value;
        
        else if (field->type == JvPrimClass (int))
          *(jint*)addr = (jint)value;

        else
          throw_class_format_error ("erroneous field initializer");
      }  
      break;

    case JV_CONSTANT_Long:
      if (field->type != JvPrimClass (long))
        throw_class_format_error ("erroneous field initializer");

      *(jlong*)addr = _Jv_loadLong (&pool->data[init]);
      break;

    case JV_CONSTANT_Float:
      if (field->type != JvPrimClass (float))
        throw_class_format_error ("erroneous field initializer");

      *(jfloat*)addr = pool->data[init].f;
      break;

    case JV_CONSTANT_Double:
      if (field->type != JvPrimClass (double))
        throw_class_format_error ("erroneous field initializer");

      *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]);
      break;

    default:
      throw_class_format_error ("erroneous field initializer");
    }
}

static int
get_alignment_from_class (jclass klass)
{
  if (klass == JvPrimClass (byte))
    return  __alignof__ (jbyte);
  else if (klass == JvPrimClass (short))
    return  __alignof__ (jshort);
  else if (klass == JvPrimClass (int)) 
    return  __alignof__ (jint);
  else if (klass == JvPrimClass (long))
    return  __alignof__ (jlong);
  else if (klass == JvPrimClass (boolean))
    return  __alignof__ (jboolean);
  else if (klass == JvPrimClass (char))
    return  __alignof__ (jchar);
  else if (klass == JvPrimClass (float))
    return  __alignof__ (jfloat);
  else if (klass == JvPrimClass (double))
    return  __alignof__ (jdouble);
  else
    return __alignof__ (jobject);
}


inline static unsigned char*
skip_one_type (unsigned char* ptr)
{
  int ch = *ptr++;

  while (ch == '[')
    { 
      ch = *ptr++;
    }
  
  if (ch == 'L')
    {
      do { ch = *ptr++; } while (ch != ';');
    }

  return ptr;
}

static ffi_type*
get_ffi_type_from_signature (unsigned char* ptr)
{
  switch (*ptr) 
    {
    case 'L':
    case '[':
      return &ffi_type_pointer;
      break;

    case 'Z':
      // On some platforms a bool is a byte, on others an int.
      if (sizeof (jboolean) == sizeof (jbyte))
        return &ffi_type_sint8;
      else
        {
          JvAssert (sizeof (jbyte) == sizeof (jint));
          return &ffi_type_sint32;
        }
      break;

    case 'B':
      return &ffi_type_sint8;
      break;
      
    case 'C':
      return &ffi_type_uint16;
      break;
          
    case 'S': 
      return &ffi_type_sint16;
      break;
          
    case 'I':
      return &ffi_type_sint32;
      break;
          
    case 'J':
      return &ffi_type_sint64;
      break;
          
    case 'F':
      return &ffi_type_float;
      break;
          
    case 'D':
      return &ffi_type_double;
      break;

    case 'V':
      return &ffi_type_void;
      break;
    }

  throw_internal_error ("unknown type in signature");
}

/* this function yields the number of actual arguments, that is, if the
 * function is non-static, then one is added to the number of elements
 * found in the signature */

int 
_Jv_count_arguments (_Jv_Utf8Const *signature,
                     jboolean staticp)
{
  unsigned char *ptr = (unsigned char*) signature->data;
  int arg_count = staticp ? 0 : 1;

  /* first, count number of arguments */

  // skip '('
  ptr++;

  // count args
  while (*ptr != ')')
    {
      ptr = skip_one_type (ptr);
      arg_count += 1;
    }

  return arg_count;
}

/* This beast will build a cif, given the signature.  Memory for
 * the cif itself and for the argument types must be allocated by the
 * caller.
 */

static int 
init_cif (_Jv_Utf8Const* signature,
          int arg_count,
          jboolean staticp,
          ffi_cif *cif,
          ffi_type **arg_types,
          ffi_type **rtype_p)
{
  unsigned char *ptr = (unsigned char*) signature->data;

  int arg_index = 0;            // arg number
  int item_count = 0;           // stack-item count

  // setup receiver
  if (!staticp)
    {
      arg_types[arg_index++] = &ffi_type_pointer;
      item_count += 1;
    }

  // skip '('
  ptr++;

  // assign arg types
  while (*ptr != ')')
    {
      arg_types[arg_index++] = get_ffi_type_from_signature (ptr);

      if (*ptr == 'J' || *ptr == 'D')
        item_count += 2;
      else
        item_count += 1;

      ptr = skip_one_type (ptr);
    }

  // skip ')'
  ptr++;
  ffi_type *rtype = get_ffi_type_from_signature (ptr);

  ptr = skip_one_type (ptr);
  if (ptr != (unsigned char*)signature->data + signature->length)
    throw_internal_error ("did not find end of signature");

  if (ffi_prep_cif (cif, FFI_DEFAULT_ABI,
                    arg_count, rtype, arg_types) != FFI_OK)
    throw_internal_error ("ffi_prep_cif failed");

  if (rtype_p != NULL)
    *rtype_p = rtype;

  return item_count;
}

#if FFI_NATIVE_RAW_API
#   define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure
#   define FFI_RAW_SIZE ffi_raw_size
#else
#   define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure
#   define FFI_RAW_SIZE ffi_java_raw_size
#endif

/* we put this one here, and not in interpret.cc because it
 * calls the utility routines _Jv_count_arguments 
 * which are static to this module.  The following struct defines the
 * layout we use for the stubs, it's only used in the ncode method. */

typedef struct {
  ffi_raw_closure  closure;
  ffi_cif   cif;
  ffi_type *arg_types[0];
} ncode_closure;

typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_raw*,void*);

void *
_Jv_InterpMethod::ncode ()
{
  using namespace java::lang::reflect;

  if (self->ncode != 0)
    return self->ncode;

  jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
  int arg_count = _Jv_count_arguments (self->signature, staticp);

  ncode_closure *closure =
    (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
                                        + arg_count * sizeof (ffi_type*));

  init_cif (self->signature,
            arg_count,
            staticp,
            &closure->cif,
            &closure->arg_types[0],
            NULL);

  ffi_closure_fun fun;

  args_raw_size = FFI_RAW_SIZE (&closure->cif);

  JvAssert ((self->accflags & Modifier::NATIVE) == 0);

  if ((self->accflags & Modifier::SYNCHRONIZED) != 0)
    {
      if (staticp)
        fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class;
      else
        fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object; 
    }
  else
    {
      fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
    }

  FFI_PREP_RAW_CLOSURE (&closure->closure,
                        &closure->cif, 
                        fun,
                        (void*)this);

  self->ncode = (void*)closure;
  return self->ncode;
}


void *
_Jv_JNIMethod::ncode ()
{
  using namespace java::lang::reflect;

  if (self->ncode != 0)
    return self->ncode;

  jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
  int arg_count = _Jv_count_arguments (self->signature, staticp);

  ncode_closure *closure =
    (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
                                    + arg_count * sizeof (ffi_type*));

  ffi_type *rtype;
  init_cif (self->signature,
            arg_count,
            staticp,
            &closure->cif,
            &closure->arg_types[0],
            &rtype);

  ffi_closure_fun fun;

  args_raw_size = FFI_RAW_SIZE (&closure->cif);

  // Initialize the argument types and CIF that represent the actual
  // underlying JNI function.
  int extra_args = 1;
  if ((self->accflags & Modifier::STATIC))
    ++extra_args;
  jni_arg_types = (ffi_type **) _Jv_Malloc ((extra_args + arg_count)
                                            * sizeof (ffi_type *));
  int offset = 0;
  jni_arg_types[offset++] = &ffi_type_pointer;
  if ((self->accflags & Modifier::STATIC))
    jni_arg_types[offset++] = &ffi_type_pointer;
  memcpy (&jni_arg_types[offset], &closure->arg_types[0],
          arg_count * sizeof (ffi_type *));

  if (ffi_prep_cif (&jni_cif, FFI_DEFAULT_ABI,
                    extra_args + arg_count, rtype,
                    jni_arg_types) != FFI_OK)
    throw_internal_error ("ffi_prep_cif failed for JNI function");

  JvAssert ((self->accflags & Modifier::NATIVE) != 0);

  // FIXME: for now we assume that all native methods for
  // interpreted code use JNI.
  fun = (ffi_closure_fun) &_Jv_JNIMethod::call;

  FFI_PREP_RAW_CLOSURE (&closure->closure,
                        &closure->cif, 
                        fun,
                        (void*) this);

  self->ncode = (void *) closure;
  return self->ncode;
}


/* A _Jv_ResolvedMethod is what is put in the constant pool for a
 * MethodRef or InterfacemethodRef.  */
static _Jv_ResolvedMethod*
_Jv_BuildResolvedMethod (_Jv_Method* method,
                         jclass      klass,
                         jboolean staticp,
                         jint vtable_index)
{
  int arg_count = _Jv_count_arguments (method->signature, staticp);

  _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*)
    _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod)
                    + arg_count*sizeof (ffi_type*));

  result->stack_item_count
    = init_cif (method->signature,
                arg_count,
                staticp,
                &result->cif,
                &result->arg_types[0],
                NULL);

  result->vtable_index        = vtable_index;
  result->method              = method;
  result->klass               = klass;

  return result;
}


static void
throw_class_format_error (jstring msg)
{
  throw (msg
         ? new java::lang::ClassFormatError (msg)
         : new java::lang::ClassFormatError);
}

static void
throw_class_format_error (char *msg)
{
  throw_class_format_error (JvNewStringLatin1 (msg));
}

static void
throw_internal_error (char *msg)
{
  throw new java::lang::InternalError (JvNewStringLatin1 (msg));
}


#endif /* INTERPRETER */