* Replaced c->loaded and c->linked stuff with

  c->state & CLASS_{LOADED,LINKED}.

diff --git a/src/cacao/cacao.c b/src/cacao/cacao.c
index d702287ee4ab7e46afe64d1fc87c581a9ea9e9df..01fedfad9dce333f099efc6d50e5d8173a77d774 100644 (file)
--- a/src/cacao/cacao.c
+++ b/src/cacao/cacao.c
@@ -37,7 +37,7 @@
      - Calling the class loader
      - Running the main method
 
-   $Id: cacao.c 3840 2005-12-02 15:15:39Z twisti $
+   $Id: cacao.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -1408,7 +1408,7 @@ int main(int argc, char **argv)
                                        if (!c)
                                                continue;
 
-                                       if (!c->linked)
+                                       if (!(c->state & CLASS_LINKED))
                                                if (!link_class(c))
                                                        throw_main_exception_exit();
 
@@ -1499,7 +1499,7 @@ void cacao_exit(s4 status)
        methodinfo *m;
 
        assert(class_java_lang_System);
-       assert(class_java_lang_System->loaded);
+       assert(class_java_lang_System->state & CLASS_LOADED);
 
 #if defined(ENABLE_JVMTI)
        set_jvmti_phase(JVMTI_PHASE_DEAD);

diff --git a/src/native/vm/VMClass.c b/src/native/vm/VMClass.c
index fe87af8625064eee2a8155c29576c1c77e9d3cbe..2caa803417a2ebcdf138c9925d412a6196e024b8 100644 (file)
--- a/src/native/vm/VMClass.c
+++ b/src/native/vm/VMClass.c
@@ -29,7 +29,7 @@
    Changes: Joseph Wenninger
             Christian Thalinger
 
-   $Id: VMClass.c 3829 2005-12-01 19:47:56Z twisti $
+   $Id: VMClass.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -293,7 +293,7 @@ JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getDeclaredClasses(JN
                                                                                           &inner))
                                return NULL;
 
-                       if (!inner->linked)
+                       if (!(inner->state & CLASS_LINKED))
                                if (!link_class(inner))
                                        return NULL;
 
@@ -345,7 +345,7 @@ JNIEXPORT java_lang_Class* JNICALL Java_java_lang_VMClass_getDeclaringClass(JNIE
                                                                                                   &outer))
                                        return NULL;
 
-                               if (!outer->linked)
+                               if (!(outer->state & CLASS_LINKED))
                                        if (!link_class(outer))
                                                return NULL;
 
@@ -434,7 +434,7 @@ JNIEXPORT java_objectarray* JNICALL Java_java_lang_VMClass_getInterfaces(JNIEnv
 
        c = (classinfo *) klass;
 
-       if (!c->linked)
+       if (!(c->state & CLASS_LINKED))
                if (!link_class(c))
                        return NULL;
 
@@ -629,7 +629,7 @@ JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isArray(JNIEnv *env, jclass clazz, j
 {
        classinfo *c = (classinfo *) klass;
 
-       if (!c->linked)
+       if (!(c->state & CLASS_LINKED))
                if (!link_class(c))
                        return 0;
 
@@ -655,11 +655,11 @@ JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isAssignableFrom(JNIEnv *env, jclass
                return 0;
        }
 
-       if (!kc->linked)
+       if (!(kc->state & CLASS_LINKED))
                if (!link_class(kc))
                        return 0;
 
-       if (!cc->linked)
+       if (!(cc->state & CLASS_LINKED))
                if (!link_class(cc))
                        return 0;
 
@@ -682,7 +682,7 @@ JNIEXPORT s4 JNICALL Java_java_lang_VMClass_isInstance(JNIEnv *env, jclass clazz
        c = (classinfo *) klass;
        ob = (java_objectheader *) o;
 
-       if (!c->linked)
+       if (!(c->state & CLASS_LINKED))
                if (!link_class(c))
                        return 0;
 

diff --git a/src/native/vm/VMClassLoader.c b/src/native/vm/VMClassLoader.c
index 3287215a3d769563b1ee231551ac4cd83e63cd99..e9df30a45297e75283f07e9af2036e538e292605 100644 (file)
--- a/src/native/vm/VMClassLoader.c
+++ b/src/native/vm/VMClassLoader.c
@@ -30,7 +30,7 @@
             Christian Thalinger
             Edwin Steiner
 
-   $Id: VMClassLoader.c 3846 2005-12-03 12:19:38Z twisti $
+   $Id: VMClassLoader.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -236,7 +236,7 @@ JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass(JNIEnv *env, jc
 
        /* link the class */
 
-       if (!ci->linked)
+       if (!(ci->state & CLASS_LINKED))
                link_class(ci);
 
        return;

diff --git a/src/vm/builtin.c b/src/vm/builtin.c
index 8d82ddc525a6afd23bbd9146477fdfe4d87a2a53..557ec781b325a0a157455d4c5d3f554349799aab 100644 (file)
--- a/src/vm/builtin.c
+++ b/src/vm/builtin.c
@@ -36,7 +36,7 @@
    calls instead of machine instructions, using the C calling
    convention.
 
-   $Id: builtin.c 3854 2005-12-03 12:35:43Z twisti $
+   $Id: builtin.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -72,6 +72,7 @@
 #include "toolbox/logging.h"
 #include "toolbox/util.h"
 #include "vm/builtin.h"
+#include "vm/class.h"
 #include "vm/exceptions.h"
 #include "vm/global.h"
 #include "vm/initialize.h"
@@ -725,7 +726,7 @@ java_objectheader *builtin_new(classinfo *c)
 
        /* is the class loaded */
 
-       assert(c->loaded);
+       assert(c->state & CLASS_LOADED);
 
        /* check if we can instantiate this class */
 
@@ -738,7 +739,7 @@ java_objectheader *builtin_new(classinfo *c)
 
        /* is the class linked */
 
-       if (!c->linked)
+       if (!(c->state & CLASS_LINKED))
                if (!link_class(c))
                        return NULL;
 
@@ -830,11 +831,11 @@ java_objectarray *builtin_anewarray(s4 size, classinfo *componentclass)
        
        /* is class loaded */
 
-       assert(componentclass->loaded);
+       assert(componentclass->state & CLASS_LOADED);
 
        /* is class linked */
 
-       if (!componentclass->linked)
+       if (!(componentclass->state & CLASS_LINKED))
                if (!link_class(componentclass))
                        return NULL;
 

diff --git a/src/vm/class.c b/src/vm/class.c
index ea0a6e2a61c9510ce60a7b98fcd5328646b6182d..219ed6645d87f201cf31b00d1eab723c9c0d62f7 100644 (file)
--- a/src/vm/class.c
+++ b/src/vm/class.c
@@ -30,7 +30,7 @@
             Andreas Krall
             Christian Thalinger
 
-   $Id: class.c 3859 2005-12-03 13:00:28Z twisti $
+   $Id: class.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -459,14 +459,14 @@ static classinfo *get_array_class(utf *name,java_objectheader *initloader,
        }
 
        CLASS_ASSERT(c);
-       CLASS_ASSERT(c->loaded);
+       CLASS_ASSERT(c->state & CLASS_LOADED);
        CLASS_ASSERT(c->classloader == defloader);
 
-       if (link && !c->linked)
+       if (link && !(c->state & CLASS_LINKED))
                if (!link_class(c))
                        return NULL;
 
-       CLASS_ASSERT(!link || c->linked);
+       CLASS_ASSERT(!link || (c->state & CLASS_LINKED));
 
        return c;
 }

diff --git a/src/vm/classcache.c b/src/vm/classcache.c
index fd9cb49217d5d2a0167d4befa6fbba40a5fdc373..c5563ccf0f9676cff958a6f23def9a277e8642bb 100644 (file)
--- a/src/vm/classcache.c
+++ b/src/vm/classcache.c
@@ -28,7 +28,7 @@
 
    Changes: Christian Thalinger
 
-   $Id: classcache.c 3837 2005-12-01 23:50:28Z twisti $
+   $Id: classcache.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -507,9 +507,8 @@ classinfo *classcache_lookup_defined_or_initiated(classloader *loader,
    
 *******************************************************************************/
 
-classinfo * classcache_store(classloader * initloader,
-                                                        classinfo * cls,
-                                                        bool mayfree)
+classinfo *classcache_store(classloader *initloader, classinfo *cls,
+                                                       bool mayfree)
 {
        classcache_name_entry *en;
        classcache_class_entry *clsen;
@@ -519,7 +518,7 @@ classinfo * classcache_store(classloader * initloader,
 #endif
        
        assert(cls);
-       assert(cls->loaded != 0);
+       assert(cls->state & CLASS_LOADED);
 
        CLASSCACHE_LOCK();
 
@@ -652,7 +651,7 @@ bool classcache_store_unique(classinfo *cls)
    
 *******************************************************************************/
 
-classinfo * classcache_store_defined(classinfo *cls)
+classinfo *classcache_store_defined(classinfo *cls)
 {
        classcache_name_entry *en;
        classcache_class_entry *clsen;
@@ -661,7 +660,7 @@ classinfo * classcache_store_defined(classinfo *cls)
 #endif
 
        assert(cls);
-       assert(cls->loaded != 0);
+       assert(cls->state & CLASS_LOADED);
 
        CLASSCACHE_LOCK();
 

diff --git a/src/vm/initialize.c b/src/vm/initialize.c
index aa8c1f0f1bc4c31ae8aa7d30033765d028505c02..90c5b5a4c0133cf2095e008001aa50f783863d01 100644 (file)
--- a/src/vm/initialize.c
+++ b/src/vm/initialize.c
@@ -30,7 +30,7 @@
             Andreas Krall
             Christian Thalinger
 
-   $Id: initialize.c 3858 2005-12-03 12:58:36Z twisti $
+   $Id: initialize.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -149,7 +149,7 @@ static bool initialize_class_intern(classinfo *c)
 
        /* maybe the class is not already linked */
 
-       if (!c->linked)
+       if (!(c->state & CLASS_LINKED))
                if (!link_class(c))
                        return false;
 

diff --git a/src/vm/jit/inline/parseXTA.h b/src/vm/jit/inline/parseXTA.h
index c1b8279527690846e5f3cf8b916e3a14c2226959..9a20dbde007ba161964cdba6c8570758ecdfd320 100644 (file)
--- a/src/vm/jit/inline/parseXTA.h
+++ b/src/vm/jit/inline/parseXTA.h
@@ -26,7 +26,7 @@
 
    Authors: Carolyn Oates
 
-   $Id: parseXTA.h 2193 2005-04-02 19:33:43Z edwin $
+   $Id: parseXTA.h 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -45,14 +45,14 @@ typedef     struct xtafldinfo xtafldinfo;
 
 
 #define LAZYLOADING(class) { \
-        if (!class->linked) \
+        if (!(class->state & CLASS_LINKED)) \
             if (!link_class(class)) \
                 return 0; }
 
 
 
 #define LAZYLOADING1(class) { \
-        if (!class->linked) \
+        if (!(class->state & CLASS_LINKED)) \
             if (!link_class(class)) \
                 return; }
 

diff --git a/src/vm/jit/verify/typeinfo.c b/src/vm/jit/verify/typeinfo.c
index 1981994fab2feae308f1eece451296a2291407d8..4f09204988f97b1b06fe94c999867e09ce5313e3 100644 (file)
--- a/src/vm/jit/verify/typeinfo.c
+++ b/src/vm/jit/verify/typeinfo.c
@@ -26,7 +26,7 @@
 
    Authors: Edwin Steiner
 
-   $Id: typeinfo.c 3829 2005-12-01 19:47:56Z twisti $
+   $Id: typeinfo.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -782,7 +782,7 @@ interface_extends_interface(classinfo *cls,classinfo *interf)
        TYPEINFO_ASSERT(interf);
        TYPEINFO_ASSERT((interf->flags & ACC_INTERFACE) != 0);
        TYPEINFO_ASSERT((cls->flags & ACC_INTERFACE) != 0);
-       TYPEINFO_ASSERT(cls->linked);
+       TYPEINFO_ASSERT(cls->state & CLASS_LINKED);
 
     /* first check direct superinterfaces */
     for (i=0; i<cls->interfacescount; ++i) {
@@ -821,7 +821,7 @@ classinfo_implements_interface(classinfo *cls,classinfo *interf)
        TYPEINFO_ASSERT(interf);
        TYPEINFO_ASSERT((interf->flags & ACC_INTERFACE) != 0);
 
-       if (!cls->linked)
+       if (!(cls->state & CLASS_LINKED))
                if (!link_class(cls))
                        return typecheck_FAIL;
 
@@ -834,7 +834,7 @@ classinfo_implements_interface(classinfo *cls,classinfo *interf)
         return interface_extends_interface(cls,interf);
     }
 
-       TYPEINFO_ASSERT(cls->linked);
+       TYPEINFO_ASSERT(cls->state & CLASS_LINKED);
     return CLASSINFO_IMPLEMENTS_INTERFACE(cls,interf->index);
 }
 
@@ -971,8 +971,8 @@ merged_is_subclass(classinfo *typeclass,typeinfo_mergedlist *merged,
     if (typeclass == pseudo_class_Null)
         return typecheck_TRUE;
 
-       TYPEINFO_ASSERT(typeclass->loaded);
-       TYPEINFO_ASSERT(typeclass->linked);
+       TYPEINFO_ASSERT(typeclass->state & CLASS_LOADED);
+       TYPEINFO_ASSERT(typeclass->state & CLASS_LINKED);
 
     /* check if the common typeclass is a subclass of CLS. */
        if (class_issubclass(typeclass,cls))
@@ -992,7 +992,7 @@ merged_is_subclass(classinfo *typeclass,typeinfo_mergedlist *merged,
                if (IS_CLASSREF(*mlist)) {
                        return typecheck_MAYBE;
                }
-               if (!mlist->cls->linked)
+               if (!(mlist->cls->state & CLASS_LINKED))
                        if (!link_class(mlist->cls))
                                return typecheck_FAIL;
                if (!class_issubclass(mlist->cls,cls))
@@ -1089,20 +1089,20 @@ typeinfo_is_assignable_to_class(typeinfo *value,classref_or_classinfo dest)
 
        cls = c.cls;
        
-       TYPEINFO_ASSERT(cls->loaded);
-       TYPEINFO_ASSERT(dest.cls->loaded);
+       TYPEINFO_ASSERT(cls->state & CLASS_LOADED);
+       TYPEINFO_ASSERT(dest.cls->state & CLASS_LOADED);
 
        /* maybe we need to link the classes */
-       if (!cls->linked)
+       if (!(cls->state & CLASS_LINKED))
                if (!link_class(cls))
                        return typecheck_FAIL;
-       if (!dest.cls->linked)
+       if (!(dest.cls->state & CLASS_LINKED))
                if (!link_class(dest.cls))
                        return typecheck_FAIL;
 
        /* { we know that both c and dest are linked classes } */
-       TYPEINFO_ASSERT(cls->linked);
-       TYPEINFO_ASSERT(dest.cls->linked);
+       TYPEINFO_ASSERT(cls->state & CLASS_LINKED);
+       TYPEINFO_ASSERT(dest.cls->state & CLASS_LINKED);
 
     if (dest.cls->flags & ACC_INTERFACE) {
         /* We are assigning to an interface type. */
@@ -1604,7 +1604,7 @@ typeinfo_init_component(typeinfo *srcarray,typeinfo *dst)
        else {
                vftbl_t *comp;
                
-               if (!srcarray->typeclass.cls->linked) {
+               if (!(srcarray->typeclass.cls->state & CLASS_LINKED)) {
                        if (!link_class(srcarray->typeclass.cls)) {
                                return false;
                        }
@@ -1985,8 +1985,8 @@ typeinfo_merge_nonarrays(typeinfo *dest,
        }
 #endif
 
-       TYPEINFO_ASSERT(IS_CLASSREF(x) || x.cls->loaded);
-       TYPEINFO_ASSERT(IS_CLASSREF(y) || y.cls->loaded);
+       TYPEINFO_ASSERT(IS_CLASSREF(x) || (x.cls->state & CLASS_LOADED));
+       TYPEINFO_ASSERT(IS_CLASSREF(y) || (y.cls->state & CLASS_LOADED));
 
     /* If y is unresolved or an interface, swap x and y. */
     if (IS_CLASSREF(y) || (!IS_CLASSREF(x) && y.cls->flags & ACC_INTERFACE))
@@ -2015,8 +2015,8 @@ typeinfo_merge_nonarrays(typeinfo *dest,
     /* {We know: If only one of x,y is an interface it is x.} */
 
        TYPEINFO_ASSERT(!IS_CLASSREF(x) && !IS_CLASSREF(y));
-       TYPEINFO_ASSERT(x.cls->loaded);
-       TYPEINFO_ASSERT(y.cls->loaded);
+       TYPEINFO_ASSERT(x.cls->state & CLASS_LOADED);
+       TYPEINFO_ASSERT(y.cls->state & CLASS_LOADED);
 
     /* Handle merging of interfaces: */
     if (x.cls->flags & ACC_INTERFACE) {
@@ -2044,15 +2044,15 @@ typeinfo_merge_nonarrays(typeinfo *dest,
          */
 
                /* we may have to link the classes */
-               if (!x.cls->linked)
+               if (!(x.cls->state & CLASS_LINKED))
                        if (!link_class(x.cls))
                                return typecheck_FAIL;
-               if (!y.cls->linked)
+               if (!(y.cls->state & CLASS_LINKED))
                        if (!link_class(y.cls))
                                return typecheck_FAIL;
         
-               TYPEINFO_ASSERT(x.cls->linked);
-               TYPEINFO_ASSERT(y.cls->linked);
+               TYPEINFO_ASSERT(x.cls->state & CLASS_LINKED);
+               TYPEINFO_ASSERT(y.cls->state & CLASS_LINKED);
 
         if (CLASSINFO_IMPLEMENTS_INTERFACE(y.cls,x.cls->index))
                {
@@ -2079,15 +2079,15 @@ typeinfo_merge_nonarrays(typeinfo *dest,
     /* {We know: x and y are classes (not interfaces).} */
     
        /* we may have to link the classes */
-       if (!x.cls->linked)
+       if (!(x.cls->state & CLASS_LINKED))
                if (!link_class(x.cls))
                        return typecheck_FAIL;
-       if (!y.cls->linked)
+       if (!(y.cls->state & CLASS_LINKED))
                if (!link_class(y.cls))
                        return typecheck_FAIL;
         
-       TYPEINFO_ASSERT(x.cls->linked);
-       TYPEINFO_ASSERT(y.cls->linked);
+       TYPEINFO_ASSERT(x.cls->state & CLASS_LINKED);
+       TYPEINFO_ASSERT(y.cls->state & CLASS_LINKED);
 
     /* If *x is deeper in the inheritance hierarchy swap x and y. */
     if (x.cls->index > y.cls->index) {

diff --git a/src/vm/linker.c b/src/vm/linker.c
index 7acf65db72c78b39db5fed0123a2f279b6967b90..0981baf388c1136be921905ddce28c308cafaac8 100644 (file)
--- a/src/vm/linker.c
+++ b/src/vm/linker.c
@@ -32,7 +32,7 @@
             Edwin Steiner
             Christian Thalinger
 
-   $Id: linker.c 3825 2005-12-01 18:46:29Z edwin $
+   $Id: linker.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -219,14 +219,14 @@ bool linker_init(void)
 
     /* pseudo class for Arraystubs (extends java.lang.Object) */
     
-    pseudo_class_Arraystub =
+       pseudo_class_Arraystub =
                class_create_classinfo(utf_new_char("$ARRAYSTUB$"));
-       pseudo_class_Arraystub->loaded = true;
-    pseudo_class_Arraystub->super.cls = class_java_lang_Object;
-    pseudo_class_Arraystub->interfacescount = 2;
-    pseudo_class_Arraystub->interfaces = MNEW(classref_or_classinfo, 2);
-    pseudo_class_Arraystub->interfaces[0].cls = class_java_lang_Cloneable;
-    pseudo_class_Arraystub->interfaces[1].cls = class_java_io_Serializable;
+       pseudo_class_Arraystub->state |= CLASS_LOADED;
+       pseudo_class_Arraystub->super.cls = class_java_lang_Object;
+       pseudo_class_Arraystub->interfacescount = 2;
+       pseudo_class_Arraystub->interfaces = MNEW(classref_or_classinfo, 2);
+       pseudo_class_Arraystub->interfaces[0].cls = class_java_lang_Cloneable;
+       pseudo_class_Arraystub->interfaces[1].cls = class_java_io_Serializable;
 
        if (!classcache_store_unique(pseudo_class_Arraystub)) {
                log_text("could not cache pseudo_class_Arraystub");
@@ -237,9 +237,9 @@ bool linker_init(void)
                return false;
 
        /* pseudo class representing the null type */
-    
+
        pseudo_class_Null = class_create_classinfo(utf_new_char("$NULL$"));
-       pseudo_class_Null->loaded = true;
+       pseudo_class_Null->state |= CLASS_LOADED;
        pseudo_class_Null->super.cls = class_java_lang_Object;
 
        if (!classcache_store_unique(pseudo_class_Null)) {
@@ -253,8 +253,8 @@ bool linker_init(void)
        /* pseudo class representing new uninitialized objects */
     
        pseudo_class_New = class_create_classinfo(utf_new_char("$NEW$"));
-       pseudo_class_New->loaded = true;
-       pseudo_class_New->linked = true; /* XXX is this allright? */
+       pseudo_class_New->state |= CLASS_LOADED;
+       pseudo_class_New->state |= CLASS_LINKED; /* XXX is this allright? */
        pseudo_class_New->super.cls = class_java_lang_Object;
 
        if (!classcache_store_unique(pseudo_class_New)) {
@@ -305,7 +305,7 @@ static bool link_primitivetype_table(void)
                
                /* prevent loader from loading primitive class */
 
-               c->loaded = true;
+               c->state |= CLASS_LOADED;
 
                /* INFO: don't put primitive classes into the classcache */
 
@@ -336,8 +336,9 @@ static bool link_primitivetype_table(void)
 
                        primitivetype_table[i].arrayclass = c;
 
-                       assert(c->loaded);
-                       if (!c->linked)
+                       assert(c->state & CLASS_LOADED);
+
+                       if (!(c->state & CLASS_LINKED))
                                if (!link_class(c))
                                        return false;
 
@@ -372,7 +373,8 @@ classinfo *link_class(classinfo *c)
 #endif
 
        /* maybe the class is already linked */
-       if (c->linked) {
+
+       if (c->state & CLASS_LINKED) {
 #if defined(USE_THREADS)
                builtin_monitorexit((java_objectheader *) c);
 #endif
@@ -397,7 +399,7 @@ classinfo *link_class(classinfo *c)
        /* if return value is NULL, we had a problem and the class is not linked */
 
        if (!r)
-               c->linked = false;
+               c->state &= ~CLASS_LINKING;
 
 #if defined(STATISTICS)
        /* measure time */
@@ -438,9 +440,9 @@ static classinfo *link_class_intern(classinfo *c)
        s4 i,j;                       /* interface/method/field counter           */
        arraydescriptor *arraydesc;   /* descriptor for array classes             */
 
-       /* maybe the class is already linked */
+       /* the class is already linked */
 
-       if (c->linked)
+       if (c->state & CLASS_LINKED)
                return c;
 
        if (linkverbose)
@@ -448,9 +450,8 @@ static classinfo *link_class_intern(classinfo *c)
 
        /* the class must be loaded */
 
-       if (!c->loaded)
-               throw_cacao_exception_exit(string_java_lang_InternalError,
-                                                                  "Trying to link unloaded class");
+       /* XXX should this be a specific exception? */
+       assert(c->state & CLASS_LOADED);
 
        /* cache the self-reference of this class                          */
        /* we do this for cases where the defining loader of the class     */
@@ -462,9 +463,9 @@ static classinfo *link_class_intern(classinfo *c)
        if (c->classloader)
                classcache_store(c->classloader,c,false);
 
-       /* ok, this class is somewhat linked */
+       /* this class is currently linking */
 
-       c->linked = true;
+       c->state |= CLASS_LINKING;
 
        arraydesc = NULL;
 
@@ -488,7 +489,7 @@ static classinfo *link_class_intern(classinfo *c)
                        return NULL;
                }
 
-               assert(tc->loaded);
+               assert(tc->state & CLASS_LOADED);
 
                if (!(tc->flags & ACC_INTERFACE)) {
                        *exceptionptr =
@@ -497,7 +498,7 @@ static classinfo *link_class_intern(classinfo *c)
                        return NULL;
                }
 
-               if (!tc->linked)
+               if (!(tc->state & CLASS_LINKED))
                        if (!link_class(tc))
                                return NULL;
        }
@@ -533,7 +534,7 @@ static classinfo *link_class_intern(classinfo *c)
                        return NULL;
                }
 
-               assert(super->loaded);
+               assert(super->state & CLASS_LOADED);
 
                if (super->flags & ACC_INTERFACE) {
                        /* java.lang.IncompatibleClassChangeError: class a has interface java.lang.Cloneable as super class */
@@ -550,7 +551,7 @@ static classinfo *link_class_intern(classinfo *c)
                        return NULL;
                }
                
-               if (!super->linked)
+               if (!(super->state & CLASS_LINKED))
                        if (!link_class(super))
                                return NULL;
 
@@ -821,6 +822,10 @@ static classinfo *link_class_intern(classinfo *c)
 
        linker_compute_subclasses(c);
 
+       /* revert the linking state and class is linked */
+
+       c->state = (c->state & ~CLASS_LINKING) | CLASS_LINKED;
+
        if (linkverbose)
                log_message_class("Linking done class: ", c);
 
@@ -870,14 +875,15 @@ static arraydescriptor *link_array(classinfo *c)
        }
 
        /* If the component type has not been linked, link it now */
-       assert(!comp || comp->loaded);
-       if (comp && !comp->linked) {
 
+       assert(!comp || (comp->state & CLASS_LOADED));
+
+       if (comp && !(comp->state & CLASS_LINKED))
                if (!link_class(comp))
                        return NULL;
-       }
 
        /* Allocate the arraydescriptor */
+
        desc = NEW(arraydescriptor);
 
        if (comp) {

diff --git a/src/vm/loader.c b/src/vm/loader.c
index 2427610da0695f6f4dca298084a347c3a33a5a98..4bbacc7183d8ced7cea0b5939f089f4a14ff3bc2 100644 (file)
--- a/src/vm/loader.c
+++ b/src/vm/loader.c
@@ -32,7 +32,7 @@
             Edwin Steiner
             Christian Thalinger
 
-   $Id: loader.c 3842 2005-12-02 15:26:16Z twisti $
+   $Id: loader.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -1464,7 +1464,7 @@ classinfo *load_class_from_sysloader(utf *name)
 
        LOADER_ASSERT(class_java_lang_Object);
        LOADER_ASSERT(class_java_lang_ClassLoader);
-       LOADER_ASSERT(class_java_lang_ClassLoader->linked);
+       LOADER_ASSERT(class_java_lang_ClassLoader->state & CLASS_LINKED);
        
        m = class_resolveclassmethod(class_java_lang_ClassLoader,
                                                                 utf_getSystemClassLoader,
@@ -1550,7 +1550,7 @@ classinfo *load_class_from_classloader(utf *name, java_objectheader *cl)
 
                                if (tmpc == NULL) {
                                        /* exception, free the loaded class */
-                                       c->loaded = false;
+                                       c->state &= ~CLASS_LOADING;
                                        class_free(c);
                                }
 
@@ -1572,7 +1572,7 @@ classinfo *load_class_from_classloader(utf *name, java_objectheader *cl)
 
                                if (tmpc == NULL) {
                                        /* exception, free the loaded class */
-                                       c->loaded = false;
+                                       c->state &= ~CLASS_LOADING;
                                        class_free(c);
                                }
 
@@ -1615,7 +1615,7 @@ classinfo *load_class_from_classloader(utf *name, java_objectheader *cl)
 
                        if (tmpc == NULL) {
                                /* exception, free the loaded class */
-                               c->loaded = false;
+                               c->state &= ~CLASS_LOADING;
                                class_free(c);
                        }
 
@@ -1689,7 +1689,7 @@ classinfo *load_class_bootstrap(utf *name)
                c = load_newly_created_array(c, NULL);
                if (c == NULL)
                        return NULL;
-               LOADER_ASSERT(c->loaded);
+               LOADER_ASSERT(c->state & CLASS_LOADED);
                return c;
        }
 
@@ -1803,9 +1803,9 @@ classinfo *load_class_from_classbuffer(classbuffer *cb)
 
        c = cb->class;
 
-       /* maybe the class is already loaded */
+       /* the class is already loaded */
 
-       if (c->loaded)
+       if (c->state & CLASS_LOADED)
                return c;
 
 #if defined(STATISTICS)
@@ -1822,9 +1822,9 @@ classinfo *load_class_from_classbuffer(classbuffer *cb)
 
        dumpsize = dump_size();
 
-       /* class is somewhat loaded */
+       /* class is currently loading */
 
-       c->loaded = true;
+       c->state |= CLASS_LOADING;
 
        if (!suck_check_classbuffer_size(cb, 4 + 2 + 2))
                goto return_exception;
@@ -2274,7 +2274,11 @@ classinfo *load_class_from_classbuffer(classbuffer *cb)
        /* release dump area */
 
        dump_release(dumpsize);
-       
+
+       /* revert loading state and class is loaded */
+
+       c->state = (c->state & ~CLASS_LOADING) | CLASS_LOADED;
+
        if (loadverbose)
                log_message_class("Loading done class: ", c);
 
@@ -2339,7 +2343,7 @@ classinfo *load_newly_created_array(classinfo *c, java_objectheader *loader)
                if (!(comp = load_class_from_classloader(u, loader)))
                        return NULL;
 
-               LOADER_ASSERT(comp->loaded);
+               LOADER_ASSERT(comp->state & CLASS_LOADED);
 
                if (opt_eager)
                        if (!link_class(c))
@@ -2364,7 +2368,7 @@ classinfo *load_newly_created_array(classinfo *c, java_objectheader *loader)
                if (!(comp = load_class_from_classloader(u, loader)))
                        return NULL;
 
-               LOADER_ASSERT(comp->loaded);
+               LOADER_ASSERT(comp->state & CLASS_LOADED);
 
                if (opt_eager)
                        if (!link_class(c))
@@ -2404,12 +2408,12 @@ classinfo *load_newly_created_array(classinfo *c, java_objectheader *loader)
                classinfo *tc;
 
                tc = class_java_lang_Cloneable;
-               LOADER_ASSERT(tc->loaded);
+               LOADER_ASSERT(tc->state & CLASS_LOADED);
                list_addfirst(&unlinkedclasses, tc);
                c->interfaces[0].cls = tc;
 
                tc = class_java_io_Serializable;
-               LOADER_ASSERT(tc->loaded);
+               LOADER_ASSERT(tc->state & CLASS_LOADED);
                list_addfirst(&unlinkedclasses, tc);
                c->interfaces[1].cls = tc;
 
@@ -2467,7 +2471,7 @@ classinfo *load_newly_created_array(classinfo *c, java_objectheader *loader)
 
        /* array classes are not loaded from class files */
 
-       c->loaded = true;
+       c->state |= CLASS_LOADED;
        c->parseddescs = (u1 *) clonedesc;
        c->parseddescsize = sizeof(methodinfo);
        c->classrefs = classrefs;

diff --git a/src/vm/resolve.c b/src/vm/resolve.c
index f8de23e5f231eb811b4c5b9c9cd6a895c5549c9f..359c095b2e47d85144f449b069b527aa970d1ec6 100644 (file)
--- a/src/vm/resolve.c
+++ b/src/vm/resolve.c
@@ -28,7 +28,7 @@
 
    Changes: Christan Thalinger
 
-   $Id: resolve.c 3811 2005-11-28 16:23:40Z edwin $
+   $Id: resolve.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -178,7 +178,7 @@ bool resolve_class_from_name(classinfo *referer,
 
        /* the class is now loaded */
        assert(cls);
-       assert(cls->loaded);
+       assert(cls->state & CLASS_LOADED);
 
 #ifdef RESOLVE_VERBOSE
        fprintf(stderr,"    checking access rights...\n");
@@ -203,10 +203,11 @@ bool resolve_class_from_name(classinfo *referer,
 
        /* link the class if necessary */
        if (link) {
-               if (!cls->linked)
+               if (!(cls->state & CLASS_LINKED))
                        if (!link_class(cls))
                                return false; /* exception */
-               assert(cls->linked);
+
+               assert(cls->state & CLASS_LINKED);
        }
 
        /* resolution succeeds */
@@ -316,7 +317,7 @@ bool resolve_classref_or_classinfo(methodinfo *refmethod,
        } else {
                /* cls has already been resolved */
                c = cls.cls;
-               assert(c->loaded);
+               assert(c->state & CLASS_LOADED);
        }
        assert(c || (mode == resolveLazy));
 
@@ -324,14 +325,14 @@ bool resolve_classref_or_classinfo(methodinfo *refmethod,
                return true; /* be lazy */
        
        assert(c);
-       assert(c->loaded);
+       assert(c->state & CLASS_LOADED);
 
        if (link) {
-               if (!c->linked)
+               if (!(c->state & CLASS_LINKED))
                        if (!link_class(c))
                                goto return_exception;
 
-               assert(c->linked);
+               assert(c->state & CLASS_LINKED);
        }
 
        /* succeeded */
@@ -392,14 +393,14 @@ bool resolve_class_from_typedesc(typedesc *d, bool checkaccess, bool link, class
        else {
                /* a primitive type */
                cls = primitivetype_table[d->decltype].class_primitive;
-               assert(cls->loaded);
-               if (!cls->linked)
+               assert(cls->state & CLASS_LOADED);
+               if (!(cls->state & CLASS_LINKED))
                        if (!link_class(cls))
                                return false; /* exception */
        }
        assert(cls);
-       assert(cls->loaded);
-       assert(!link || cls->linked);
+       assert(cls->state & CLASS_LOADED);
+       assert(!link || (cls->state & CLASS_LINKED));
 
 #ifdef RESOLVE_VERBOSE
        fprintf(stderr,"    result = ");utf_fprint(stderr,cls->name);fprintf(stderr,"\n");
@@ -512,8 +513,8 @@ bool resolve_and_check_subtype_set(classinfo *referer,methodinfo *refmethod,
                return true; /* be lazy */
 
        assert(type);
-       assert(type->loaded);
-       assert(type->linked);
+       assert(type->state & CLASS_LOADED);
+       assert(type->state & CLASS_LINKED);
        typeinfo_init_classinfo(&typeti,type);
 
        for (; setp->any; ++setp) {
@@ -529,8 +530,8 @@ bool resolve_and_check_subtype_set(classinfo *referer,methodinfo *refmethod,
                        return true; /* be lazy */
 
                assert(result);
-               assert(result->loaded);
-               assert(result->linked);
+               assert(result->state & CLASS_LOADED);
+               assert(result->state & CLASS_LINKED);
 
 
                /* do not check access to protected members of arrays */
@@ -657,7 +658,7 @@ bool resolve_class(unresolved_class *ref,
                return true; /* be lazy */
 
        assert(cls);
-       assert(cls->loaded && cls->linked);
+       assert((cls->state & CLASS_LOADED) && (cls->state & CLASS_LINKED));
 
        /* now we check the subtype constraints */
        if (!resolve_and_check_subtype_set(ref->classref->referer,ref->referermethod,
@@ -825,7 +826,8 @@ bool resolve_field(unresolved_field *ref,
                return true; /* be lazy */
 
        assert(container);
-       assert(container->loaded && container->linked);
+       assert(container->state & CLASS_LOADED);
+       assert(container->state & CLASS_LINKED);
 
        /* now we must find the declaration of the field in `container`
         * or one of its superclasses */
@@ -855,7 +857,8 @@ bool resolve_field(unresolved_field *ref,
        /* { the field reference has been resolved } */
        declarer = fi->class;
        assert(declarer);
-       assert(declarer->loaded && declarer->linked);
+       assert(declarer->state & CLASS_LOADED);
+       assert(declarer->state & CLASS_LINKED);
 
 #ifdef RESOLVE_VERBOSE
                fprintf(stderr,"    checking static...\n");
@@ -1076,7 +1079,7 @@ bool resolve_method(unresolved_method *ref, resolve_mode_t mode, methodinfo **re
                return true; /* be lazy */
 
        assert(container);
-       assert(container->linked);
+       assert(container->state & CLASS_LINKED);
 
        /* now we must find the declaration of the method in `container`
         * or one of its superclasses */
@@ -1116,7 +1119,7 @@ bool resolve_method(unresolved_method *ref, resolve_mode_t mode, methodinfo **re
 
        declarer = mi->class;
        assert(declarer);
-       assert(referer->linked);
+       assert(referer->state & CLASS_LINKED);
 
        /* checks for INVOKESPECIAL:                                       */
        /* for <init> and methods of the current class we don't need any   */
@@ -1629,7 +1632,9 @@ bool constrain_unresolved_field(unresolved_field *ref,
                        }
                        /* XXX check that class of field == refmethod->class */
                        initclass = refmethod->class; /* XXX classrefs */
-                       assert(initclass->loaded && initclass->linked);
+                       assert(initclass->state & CLASS_LOADED);
+                       assert(initclass->state & CLASS_LINKED);
+
                        typeinfo_init_classinfo(&tinfo,initclass);
                        insttip = &tinfo;
                }
@@ -1652,8 +1657,8 @@ bool constrain_unresolved_field(unresolved_field *ref,
                        tip = &tinfo;
                        if (INSTRUCTION_PUTCONST_VALUE_ADR(iptr)) {
                                assert(class_java_lang_String);
-                               assert(class_java_lang_String->loaded);
-                               assert(class_java_lang_String->linked);
+                               assert(class_java_lang_String->state & CLASS_LOADED);
+                               assert(class_java_lang_String->state & CLASS_LINKED);
                                typeinfo_init_classinfo(&tinfo,class_java_lang_String);
                        }
                        else

diff --git a/src/vm/string.c b/src/vm/string.c
index 306c50bbc89399df0c971809f875d8b969e8e8fc..1d758cc6fd84012712ca17e8787d7d563759933f 100644 (file)
--- a/src/vm/string.c
+++ b/src/vm/string.c
@@ -30,7 +30,7 @@
 
    Changes: Christian Thalinger
 
-   $Id: string.c 3832 2005-12-01 23:19:29Z twisti $
+   $Id: string.c 3888 2005-12-05 22:08:45Z twisti $
 
 */
 
@@ -546,7 +546,7 @@ java_objectheader *literalstring_u2(java_chararray *a, u4 length, u4 offset,
                class_java_lang_String = load_class_bootstrap(utf_java_lang_String);
 
        assert(class_java_lang_String);
-       assert(class_java_lang_String->loaded);
+       assert(class_java_lang_String->state & CLASS_LOADED);
 
        /* if we use eager loading, we have to check loaded String class */