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

/* Copyright (C) 1999, 2000, 2001  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);
	  // FIXME: enable once verifier is more fully tested.
	  // _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 */