class.c (make_class_data): Add new field aux_info.

2004-04-19  Bryce McKinlay  <mckinlay@redhat.com>

	* class.c (make_class_data): Add new field aux_info.
	* decl.c (java_init_decl_processing): Push type and decl for
	`aux_info'.

2004-04-19  Bryce McKinlay  <mckinlay@redhat.com>

	* gcj/cni.h (JvAllocObject): Remove these obsolete,
	undocumented CNI calls.
	* include/java-interp.h (_Jv_InterpClass): No longer
	extends java.lang.Class.
	* java/lang/Class.h (Class): Add new field `aux_info'.
	* boehm.cc (_Jv_MarkObj): Update java.lang.Class marking.
	* defineclass.cc: Remove Class<->_Jv_InterpClass casts.
	Use Class->aux_info instead.
	* jni.cc (_Jv_JNI_AllocObject): Use _Jv_AllocObject.
	* resolve.cc: Remove Class<->_Jv_InterpClass casts.
	Use Class->aux_info instead.
	* java/io/natObjectInputStream.cc (allocateObject): Use
	_Jv_AllocObject.
	* java/lang/natClass.cc (newInstance): Likewise.
	* java/lang/natClassLoader.cc (_Jv_NewClass): Likewise.
	* java/lang/natObject.cc (clone): Likewise.
	* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Likewise.
	* java/lang/natVMClassLoader.cc (defineClass): Don't use
	JvAllocObject. Allocate klass->aux_info here for interpreted
	class.

From-SVN: r80875

gcc/java/ChangeLog

+2004-04-19  Bryce McKinlay  <mckinlay@redhat.com>
+
+	* class.c (make_class_data): Add new field aux_info.
+	* decl.c (java_init_decl_processing): Push type and decl for 
+	`aux_info'.
+
 2004-04-15  Bryce McKinlay  <mckinlay@redhat.com>
 
 	* expr.c (expand_java_NEW): Don't use size argument for 

gcc/java/class.c

@@ -1723,6 +1723,7 @@ make_class_data (tree type)
   PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
   PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
   PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
+  PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
 
   FINISH_RECORD_CONSTRUCTOR (cons);
 

gcc/java/decl.c

@@ -690,6 +690,7 @@ java_init_decl_processing (void)
   PUSH_FIELD (class_type_node, field, "protectionDomain", ptr_type_node);
   PUSH_FIELD (class_type_node, field, "hack_signers", ptr_type_node);
   PUSH_FIELD (class_type_node, field, "chain", ptr_type_node);
+  PUSH_FIELD (class_type_node, field, "aux_info", ptr_type_node);
   for (t = TYPE_FIELDS (class_type_node);  t != NULL_TREE;  t = TREE_CHAIN (t))
     FIELD_PRIVATE (t) = 1;
   push_super_field (class_type_node, object_type_node);

libjava/ChangeLog

+2004-04-19  Bryce McKinlay  <mckinlay@redhat.com>
+ 
+	* gcj/cni.h (JvAllocObject): Remove these obsolete, 
+	undocumented CNI calls.
+	* include/java-interp.h (_Jv_InterpClass): No longer
+	extends java.lang.Class.
+	* java/lang/Class.h (Class): Add new field `aux_info'.
+	* boehm.cc (_Jv_MarkObj): Update java.lang.Class marking.
+	* defineclass.cc: Remove Class<->_Jv_InterpClass casts.
+	Use Class->aux_info instead.
+	* jni.cc (_Jv_JNI_AllocObject): Use _Jv_AllocObject.
+	* resolve.cc: Remove Class<->_Jv_InterpClass casts.
+	Use Class->aux_info instead.
+	* java/io/natObjectInputStream.cc (allocateObject): Use
+	_Jv_AllocObject.
+	* java/lang/natClass.cc (newInstance): Likewise.
+	* java/lang/natClassLoader.cc (_Jv_NewClass): Likewise.
+	* java/lang/natObject.cc (clone): Likewise.
+	* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Likewise.
+	* java/lang/natVMClassLoader.cc (defineClass): Don't use
+	JvAllocObject. Allocate klass->aux_info here for interpreted
+	class.
+	
 2004-04-17  Mark Wielaard  <mark@klomp.org>
 
 	* javax/swing/JToggleButton.java (ToggleButtonModel):

libjava/boehm.cc

@@ -208,11 +208,13 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cPlabel);
       p = (ptr_t) c->hack_signers;
       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cSlabel);
+      p = (ptr_t) c->aux_info;
+      MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cTlabel);
 
 #ifdef INTERPRETER
       if (_Jv_IsInterpretedClass (c))
 	{
-	  _Jv_InterpClass* ic = (_Jv_InterpClass*) c;
+	  _Jv_InterpClass* ic = (_Jv_InterpClass*) c->aux_info;
 
 	  p = (ptr_t) ic->interpreted_methods;
 	  MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, cElabel);

libjava/defineclass.cc

@@ -96,7 +96,10 @@ struct _Jv_ClassReader {
   unsigned int      *offsets;
 
   // the class to define (see java-interp.h)
-  _Jv_InterpClass   *def;
+  jclass	   def;
+  
+  // the classes associated interpreter data.
+  _Jv_InterpClass  *def_interp;
 
   /* check that the given number of input bytes are available */
   inline void check (int num)
@@ -221,7 +224,8 @@ struct _Jv_ClassReader {
     bytes  = (unsigned char*) (elements (data)+offset);
     len    = length;
     pos    = 0;
-    def    = (_Jv_InterpClass*) klass;
+    def    = klass;
+    def_interp = (_Jv_InterpClass *) def->aux_info;
   }
 
   /** and here goes the parser members defined out-of-line */
@@ -1047,10 +1051,10 @@ void _Jv_ClassReader::handleFieldsBegin (int count)
   def->fields = (_Jv_Field*) 
     _Jv_AllocBytes (count * sizeof (_Jv_Field));
   def->field_count = count;
-  def->field_initializers = (_Jv_ushort*)
+  def_interp->field_initializers = (_Jv_ushort*)
     _Jv_AllocBytes (count * sizeof (_Jv_ushort));
   for (int i = 0; i < count; i++)
-    def->field_initializers[i] = (_Jv_ushort) 0;
+    def_interp->field_initializers[i] = (_Jv_ushort) 0;
 }
 
 void _Jv_ClassReader::handleField (int field_no,
@@ -1133,7 +1137,7 @@ void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
     throw_class_format_error ("field has multiple ConstantValue attributes");
 
   field->flags |= _Jv_FIELD_CONSTANT_VALUE;
-  def->field_initializers[field_index] = value;
+  def_interp->field_initializers[field_index] = value;
 
   /* type check the initializer */
   
@@ -1153,7 +1157,7 @@ void _Jv_ClassReader::handleFieldsEnd ()
   int low            = 0;
   int high           = def->field_count-1;
   _Jv_Field  *fields = def->fields;
-  _Jv_ushort *inits  = def->field_initializers;
+  _Jv_ushort *inits  = def_interp->field_initializers;
 
   // this is kind of a raw version of quicksort.
   while (low < high)
@@ -1195,13 +1199,13 @@ _Jv_ClassReader::handleMethodsBegin (int count)
 {
   def->methods = (_Jv_Method *) _Jv_AllocBytes (sizeof (_Jv_Method) * count);
 
-  def->interpreted_methods
+  def_interp->interpreted_methods
     = (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
 					  * count);
 
   for (int i = 0; i < count; i++)
     {
-      def->interpreted_methods[i] = 0;
+      def_interp->interpreted_methods[i] = 0;
       def->methods[i].index = (_Jv_ushort) -1;
     }
 
@@ -1284,7 +1288,7 @@ void _Jv_ClassReader::handleCodeAttribute
 	  (void*) (bytes+code_start),
 	  code_length);
 
-  def->interpreted_methods[method_index] = method;
+  def_interp->interpreted_methods[method_index] = method;
 
   if ((method->self->accflags & java::lang::reflect::Modifier::STATIC))
     {
@@ -1301,7 +1305,7 @@ void _Jv_ClassReader::handleExceptionTableEntry
    int start_pc, int end_pc, int handler_pc, int catch_type)
 {
   _Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
-    (def->interpreted_methods[method_index]);
+    (def_interp->interpreted_methods[method_index]);
   _Jv_InterpException *exc = method->exceptions ();
 
   exc[exc_index].start_pc.i     = start_pc;
@@ -1319,7 +1323,7 @@ void _Jv_ClassReader::handleMethodsEnd ()
       _Jv_Method *method = &def->methods[i];
       if ((method->accflags & Modifier::NATIVE) != 0)
 	{
-	  if (def->interpreted_methods[i] != 0)
+	  if (def_interp->interpreted_methods[i] != 0)
 	    throw_class_format_error ("code provided for native method");
 	  else
 	    {
@@ -1328,7 +1332,7 @@ void _Jv_ClassReader::handleMethodsEnd ()
 	      m->defining_class = def;
 	      m->self = method;
 	      m->function = NULL;
-	      def->interpreted_methods[i] = m;
+	      def_interp->interpreted_methods[i] = m;
 	      m->deferred = NULL;
 
 	      if ((method->accflags & Modifier::STATIC))
@@ -1344,12 +1348,12 @@ void _Jv_ClassReader::handleMethodsEnd ()
 	}
       else if ((method->accflags & Modifier::ABSTRACT) != 0)
 	{
-	  if (def->interpreted_methods[i] != 0)
+	  if (def_interp->interpreted_methods[i] != 0)
 	    throw_class_format_error ("code provided for abstract method");
 	}
       else
 	{
-	  if (def->interpreted_methods[i] == 0)
+	  if (def_interp->interpreted_methods[i] == 0)
 	    throw_class_format_error ("method with no code");
 	}
     }

libjava/gcj/cni.h

@@ -20,18 +20,6 @@ details.  */
 
 #include <string.h>
 
-extern inline jobject
-JvAllocObject (jclass cls)
-{
-  return _Jv_AllocObject (cls);
-}
-
-extern inline jobject
-JvAllocObject (jclass cls, jsize sz)
-{
-  return _Jv_AllocObject (cls);
-}
-
 extern "C" jstring _Jv_NewStringUTF (const char *bytes);
 extern "C" void _Jv_InitClass (jclass);
 

libjava/include/java-interp.h

@@ -22,7 +22,6 @@ details.  */
 #include <java/lang/Class.h>
 #include <java/lang/ClassLoader.h>
 #include <java/lang/reflect/Modifier.h>
-#include <gnu/gcj/runtime/StackTrace.h>
 
 extern "C" {
 #include <ffi.h>
@@ -80,7 +79,7 @@ class _Jv_MethodBase
 {
 protected:
   // The class which defined this method.
-  _Jv_InterpClass *defining_class;
+  jclass defining_class;
 
   // The method description.
   _Jv_Method *self;
@@ -150,6 +149,7 @@ class _Jv_InterpMethod : public _Jv_MethodBase
   friend class _Jv_BytecodeVerifier;
   friend class gnu::gcj::runtime::NameFinder;
   friend class gnu::gcj::runtime::StackTrace;
+  
 
   friend void _Jv_PrepareClass(jclass);
 
@@ -158,7 +158,7 @@ class _Jv_InterpMethod : public _Jv_MethodBase
 #endif
 };
 
-class _Jv_InterpClass : public java::lang::Class
+class _Jv_InterpClass
 {
   _Jv_MethodBase **interpreted_methods;
   _Jv_ushort        *field_initializers;
@@ -185,13 +185,15 @@ extern inline void
 _Jv_Defer_Resolution (void *cl, _Jv_Method *meth, void **address)
 {
   int i;
-  _Jv_InterpClass *self = (_Jv_InterpClass *)cl;
+  jclass self = (jclass) cl;
+  _Jv_InterpClass *interp_cl = (_Jv_InterpClass*) self->aux_info;
+
   for (i = 0; i < self->method_count; i++)
     {
       _Jv_Method *m = &self->methods[i];
       if (m == meth)
 	{
-	  _Jv_MethodBase *imeth = self->interpreted_methods[i];
+	  _Jv_MethodBase *imeth = interp_cl->interpreted_methods[i];
 	  *address = imeth->deferred;
 	  imeth->deferred = address;
 	  return;

libjava/java/io/natObjectInputStream.cc

@@ -38,7 +38,7 @@ java::io::ObjectInputStream::allocateObject (jclass klass)
 	obj = NULL;	
       else
 	{
-	  obj = JvAllocObject (klass);
+	  obj = _Jv_AllocObject (klass);
 	}
     }
   catch (jthrowable t)

libjava/java/lang/Class.h

@@ -384,6 +384,7 @@ private:
 #endif
 
   friend class _Jv_BytecodeVerifier;
+  friend class _Jv_StackTrace;
   friend class gnu::gcj::runtime::StackTrace;
   friend class java::io::VMObjectStreamClass;
 
@@ -449,6 +450,9 @@ private:
   JArray<jobject> *hack_signers;
   // Used by Jv_PopClass and _Jv_PushClass to communicate with StackTrace.
   jclass chain;
+  // Additional data, specific to the generator (JIT, native, interpreter) of this 
+  // class.
+  void *aux_info;
 };
 
 #endif /* __JAVA_LANG_CLASS_H__ */

libjava/java/lang/natClass.cc

@@ -691,7 +691,7 @@ java::lang::Class::newInstance (void)
   if (! meth)
     throw new java::lang::InstantiationException (getName());
 
-  jobject r = JvAllocObject (this);
+  jobject r = _Jv_AllocObject (this);
   ((void (*) (jobject)) meth->ncode) (r);
   return r;
 }
@@ -1901,7 +1901,7 @@ _Jv_MakeVTable (jclass klass)
       || (klass->accflags & Modifier::ABSTRACT))
     return;
 
-  //  out before we can create a vtable. 
+  // Class must be laid out before we can create a vtable. 
   if (klass->vtable_method_count == -1)
     _Jv_LayoutVTableMethods (klass);
 

libjava/java/lang/natClassLoader.cc

@@ -419,7 +419,7 @@ jclass
 _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
 	      java::lang::ClassLoader *loader)
 {
-  jclass ret = (jclass) JvAllocObject (&java::lang::Class::class$);
+  jclass ret = (jclass) _Jv_AllocObject (&java::lang::Class::class$);
   ret->name = name;
   ret->superclass = superclass;
   ret->loader = loader;

libjava/java/lang/natObject.cc

@@ -98,7 +98,7 @@ java::lang::Object::clone (void)
 	throw new CloneNotSupportedException;
 
       size = klass->size();
-      r = JvAllocObject (klass, size);
+      r = _Jv_AllocObject (klass);
     }
 
   memcpy ((void *) r, (void *) this, size);

libjava/java/lang/natVMClassLoader.cc

@@ -39,8 +39,8 @@ java::lang::VMClassLoader::defineClass (java::lang::ClassLoader *loader,
 {
 #ifdef INTERPRETER
   jclass klass;
-  klass = (jclass) JvAllocObject (&java::lang::Class::class$,
-				  sizeof (_Jv_InterpClass));
+  klass = new java::lang::Class ();
+  klass->aux_info = (void *) _Jv_AllocBytes (sizeof (_Jv_InterpClass));
 
   // Synchronize on the class, so that it is not attempted initialized
   // until we're done loading.

libjava/java/lang/reflect/natMethod.cc

@@ -379,7 +379,7 @@ _Jv_CallAnyMethodA (jobject obj,
   // the JDK 1.2 docs specify that the new object must be allocated
   // before argument conversions are done.
   if (is_constructor)
-    obj = JvAllocObject (return_type);
+    obj = _Jv_AllocObject (return_type);
 
   const int size_per_arg = sizeof(jvalue);
   ffi_cif cif;

libjava/jni.cc

@@ -633,7 +633,7 @@ static jobject
       if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers()))
 	env->ex = new java::lang::InstantiationException ();
       else
-	obj = JvAllocObject (clazz);
+	obj = _Jv_AllocObject (clazz);
     }
   catch (jthrowable t)
     {

libjava/resolve.cc

@@ -367,9 +367,9 @@ _Jv_SearchMethodInClass (jclass cls, jclass klass,
 // A helper for _Jv_PrepareClass.  This adds missing `Miranda methods'
 // to a class.
 void
-_Jv_PrepareMissingMethods (jclass base2, jclass iface_class)
+_Jv_PrepareMissingMethods (jclass base, jclass iface_class)
 {
-  _Jv_InterpClass *base = reinterpret_cast<_Jv_InterpClass *> (base2);
+  _Jv_InterpClass *interp_base = (_Jv_InterpClass *) base->aux_info;
   for (int i = 0; i < iface_class->interface_count; ++i)
     {
       for (int j = 0; j < iface_class->interfaces[i]->method_count; ++j)
@@ -403,11 +403,11 @@ _Jv_PrepareMissingMethods (jclass base2, jclass iface_class)
 	      _Jv_MethodBase **new_im
 		= (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
 						      * new_count);
-	      memcpy (new_im, base->interpreted_methods,
+	      memcpy (new_im, interp_base->interpreted_methods,
 		      sizeof (_Jv_MethodBase *) * base->method_count);
 
 	      base->methods = new_m;
-	      base->interpreted_methods = new_im;
+	      interp_base->interpreted_methods = new_im;
 	      base->method_count = new_count;
 	    }
 	}
@@ -454,7 +454,7 @@ _Jv_PrepareClass(jclass klass)
   if (klass->superclass)
     java::lang::VMClassLoader::resolveClass (klass->superclass);
 
-  _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
+  _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
 
   /************ PART ONE: OBJECT LAYOUT ***************/
 
@@ -462,7 +462,7 @@ _Jv_PrepareClass(jclass klass)
   // superclasses and finding the maximum required alignment.  We
   // could consider caching this in the Class.
   int max_align = __alignof__ (java::lang::Object);
-  jclass super = clz->superclass;
+  jclass super = klass->superclass;
   while (super != NULL)
     {
       int num = JvNumInstanceFields (super);
@@ -484,23 +484,23 @@ _Jv_PrepareClass(jclass klass)
   // Although java.lang.Object is never interpreted, an interface can
   // have a null superclass.  Note that we have to lay out an
   // interface because it might have static fields.
-  if (clz->superclass)
-    instance_size = clz->superclass->size();
+  if (klass->superclass)
+    instance_size = klass->superclass->size();
   else
     instance_size = java::lang::Object::class$.size();
 
-  for (int i = 0; i < clz->field_count; i++)
+  for (int i = 0; i < klass->field_count; i++)
     {
       int field_size;
       int field_align;
 
-      _Jv_Field *field = &clz->fields[i];
+      _Jv_Field *field = &klass->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);
+	  _Jv_ResolveField (field, klass->loader);
 
 	  field_size = field->type->size ();
 	  field_align = get_alignment_from_class (field->type);
@@ -538,7 +538,7 @@ _Jv_PrepareClass(jclass klass)
   // to the alignment required for this object; this keeps us in sync
   // with our current ABI.
   instance_size = ROUND (instance_size, max_align);
-  clz->size_in_bytes = instance_size;
+  klass->size_in_bytes = instance_size;
 
   // allocate static memory
   if (static_size != 0)
@@ -547,18 +547,18 @@ _Jv_PrepareClass(jclass klass)
 
       memset (static_data, 0, static_size);
 
-      for (int i = 0; i < clz->field_count; i++)
+      for (int i = 0; i < klass->field_count; i++)
 	{
-	  _Jv_Field *field = &clz->fields[i];
+	  _Jv_Field *field = &klass->fields[i];
 
 	  if ((field->flags & Modifier::STATIC) != 0)
 	    {
 	      field->u.addr  = static_data + field->u.boffset;
-			    
-	      if (clz->field_initializers[i] != 0)
+	      
+	      if (iclass->field_initializers[i] != 0)
 		{
-		  _Jv_ResolveField (field, clz->loader);
-		  _Jv_InitField (0, clz, i);
+		  _Jv_ResolveField (field, klass->loader);
+		  _Jv_InitField (0, klass, i);
 		}
 	    }
 	}
@@ -566,31 +566,31 @@ _Jv_PrepareClass(jclass klass)
       // now we don't need the field_initializers anymore, so let the
       // collector get rid of it!
 
-      clz->field_initializers = 0;
+      iclass->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++)
+  for (int i = 0; i < klass->method_count; i++)
     {
-      _Jv_MethodBase *imeth = clz->interpreted_methods[i];
+      _Jv_MethodBase *imeth = iclass->interpreted_methods[i];
 
-      if ((clz->methods[i].accflags & Modifier::NATIVE) != 0)
+      if ((klass->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 ();
+	  klass->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 ();
+	  klass->methods[i].ncode = im->ncode ();
 
 	  // Resolve ctable entries pointing to this method.  See
 	  // _Jv_Defer_Resolution.
@@ -598,16 +598,16 @@ _Jv_PrepareClass(jclass klass)
 	  while (code)
 	    {
 	      void **target = (void **)*code;
-	      *code = clz->methods[i].ncode;
+	      *code = klass->methods[i].ncode;
 	      code = target;
 	    }
 	}
     }
 
-  if ((clz->accflags & Modifier::INTERFACE))
+  if ((klass->accflags & Modifier::INTERFACE))
     {
-      clz->state = JV_STATE_PREPARED;
-      clz->notifyAll ();
+      klass->state = JV_STATE_PREPARED;
+      klass->notifyAll ();
       return;
     }
 
@@ -619,15 +619,15 @@ _Jv_PrepareClass(jclass klass)
   // this here by searching for such methods and constructing new
   // internal declarations for them.  We only need to do this for
   // abstract classes.
-  if ((clz->accflags & Modifier::ABSTRACT))
-    _Jv_PrepareMissingMethods (clz, clz);
+  if ((klass->accflags & Modifier::ABSTRACT))
+    _Jv_PrepareMissingMethods (klass, klass);
 
-  clz->vtable_method_count = -1;
-  _Jv_MakeVTable (clz);
+  klass->vtable_method_count = -1;
+  _Jv_MakeVTable (klass);
 
   /* wooha! we're done. */
-  clz->state = JV_STATE_PREPARED;
-  clz->notifyAll ();
+  klass->state = JV_STATE_PREPARED;
+  klass->notifyAll ();
 }
 
 /** Do static initialization for fields with a constant initializer */
@@ -642,18 +642,18 @@ _Jv_InitField (jobject obj, jclass klass, int index)
   if (!_Jv_IsInterpretedClass (klass))
     return;
 
-  _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
+  _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
 
-  _Jv_Field * field = (&clz->fields[0]) + index;
+  _Jv_Field * field = (&klass->fields[0]) + index;
 
-  if (index > clz->field_count)
+  if (index > klass->field_count)
     throw_internal_error ("field out of range");
 
-  int init = clz->field_initializers[index];
+  int init = iclass->field_initializers[index];
   if (init == 0)
     return;
 
-  _Jv_Constants *pool = &clz->constants;
+  _Jv_Constants *pool = &klass->constants;
   int tag = pool->tags[init];
 
   if (! field->isResolved ())
@@ -673,12 +673,12 @@ _Jv_InitField (jobject obj, jclass klass, int index)
     {
     case JV_CONSTANT_String:
       {
-	_Jv_MonitorEnter (clz);
+	_Jv_MonitorEnter (klass);
 	jstring str;
 	str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
 	pool->data[init].string = str;
 	pool->tags[init] = JV_CONSTANT_ResolvedString;
-	_Jv_MonitorExit (clz);
+	_Jv_MonitorExit (klass);
       }
       /* fall through */