aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gcc/java/ChangeLog6
-rw-r--r--gcc/java/class.c1
-rw-r--r--gcc/java/decl.c1
-rw-r--r--libjava/ChangeLog23
-rw-r--r--libjava/boehm.cc4
-rw-r--r--libjava/defineclass.cc32
-rw-r--r--libjava/gcj/cni.h12
-rw-r--r--libjava/include/java-interp.h12
-rw-r--r--libjava/java/io/natObjectInputStream.cc2
-rw-r--r--libjava/java/lang/Class.h4
-rw-r--r--libjava/java/lang/natClass.cc4
-rw-r--r--libjava/java/lang/natClassLoader.cc2
-rw-r--r--libjava/java/lang/natObject.cc2
-rw-r--r--libjava/java/lang/natVMClassLoader.cc4
-rw-r--r--libjava/java/lang/reflect/natMethod.cc2
-rw-r--r--libjava/jni.cc2
-rw-r--r--libjava/resolve.cc82
17 files changed, 113 insertions, 82 deletions
diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index ac5a568..e2933a8 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,9 @@
+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
diff --git a/gcc/java/class.c b/gcc/java/class.c
index 3ba60bd..4ac4a4f0 100644
--- a/gcc/java/class.c
+++ b/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);
diff --git a/gcc/java/decl.c b/gcc/java/decl.c
index e0dd852..87204235 100644
--- a/gcc/java/decl.c
+++ b/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);
diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index cb652bd..70e4f8c 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,26 @@
+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):
diff --git a/libjava/boehm.cc b/libjava/boehm.cc
index 642f451..cf84918 100644
--- a/libjava/boehm.cc
+++ b/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);
diff --git a/libjava/defineclass.cc b/libjava/defineclass.cc
index 2e8b4d9..156efb5 100644
--- a/libjava/defineclass.cc
+++ b/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");
}
}
diff --git a/libjava/gcj/cni.h b/libjava/gcj/cni.h
index 4040f19..59cf673 100644
--- a/libjava/gcj/cni.h
+++ b/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);
diff --git a/libjava/include/java-interp.h b/libjava/include/java-interp.h
index 94acfae..c57c146 100644
--- a/libjava/include/java-interp.h
+++ b/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;
diff --git a/libjava/java/io/natObjectInputStream.cc b/libjava/java/io/natObjectInputStream.cc
index 8b84e7e..bb3796f 100644
--- a/libjava/java/io/natObjectInputStream.cc
+++ b/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)
diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h
index b8a8d90..86dc6a0 100644
--- a/libjava/java/lang/Class.h
+++ b/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__ */
diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc
index c11d2a1..419ed7d 100644
--- a/libjava/java/lang/natClass.cc
+++ b/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);
diff --git a/libjava/java/lang/natClassLoader.cc b/libjava/java/lang/natClassLoader.cc
index f5f37fa..9921d1d 100644
--- a/libjava/java/lang/natClassLoader.cc
+++ b/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;
diff --git a/libjava/java/lang/natObject.cc b/libjava/java/lang/natObject.cc
index 8618bf2..5855fc1 100644
--- a/libjava/java/lang/natObject.cc
+++ b/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);
diff --git a/libjava/java/lang/natVMClassLoader.cc b/libjava/java/lang/natVMClassLoader.cc
index 8de0a70..1ed3851 100644
--- a/libjava/java/lang/natVMClassLoader.cc
+++ b/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.
diff --git a/libjava/java/lang/reflect/natMethod.cc b/libjava/java/lang/reflect/natMethod.cc
index 96d293b..8f9efdb 100644
--- a/libjava/java/lang/reflect/natMethod.cc
+++ b/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;
diff --git a/libjava/jni.cc b/libjava/jni.cc
index 3e8b11b..680e0c7 100644
--- a/libjava/jni.cc
+++ b/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)
{
diff --git a/libjava/resolve.cc b/libjava/resolve.cc
index 5a859a7..85c988f 100644
--- a/libjava/resolve.cc
+++ b/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 */
generated by cgit v1.1 at 2024-11-01 04:53:12 +0000