[multiple changes]

1999-08-09  Anthony Green  <green@cygnus.com>

        * gij.cc: New file.

        * include/config.h.in: Rebuilt.
        * acconfig.h: Add INTERPRETER.

        * configure: Rebuilt.

        * Makefile.in: Rebuilt.
        * Makefile.am (libffi_files): Identify the libffi object files for
        inclusion in libgcj.
        (LIBFFIINCS): Define.

        * interpret.cc (gnu::gcj::runtime::MethodInvocation::continue1):
        Dummy definition for configurations without an interpreter.

        * java/net/natPlainSocketImpl.cc (getOption): Disamiguate call to
        java::lang::Boolean constructor.

        * include/java-interp.h: Always include java-cpool.h.

        * java/lang/natClassLoader.cc (getVMClassLoader0): Always return 0
        when INTERPRETER not defined.

        * java/lang/Class.h (finalize): Define.

        * gnu/gcj/util/path/DirectoryPathEntry.java (getURL): Catch
        IOException from File.getCanonicalPath.
        (getStream): Likewise.

        * NEWS: More news.
        * THANKS: More thanks.

1999-08-09  Kresten Krab Thorup  <krab@gnu.org>

        * resolve.cc (get_ffi_type_from_signature): Generate uint16 for
        jchar type.
        (_Jv_PrepareClass): Allow non-abstract classes to
        have abstract subclasses.
        (_Jv_ResolvePoolEntry): Revert subclass check for protected
        fields and methods.
        * interpret.cc (continue1/perform_invoke): Don't sign extend
        uint16 return val.
        (continue1/lshl,lshr): Push long, not int.
        (continue1/ulshr): Use UINT64, not long long.
        * defineclass.cc (handleFieldsEnd): Handle case when all fields
        are static.
        * java/lang/natClass.cc (forName): Add call to _Jv_InitClass.
        * java/lang/FirstThread.java (run): Add top-level exception
        handler.
        (run0): Renamed from run.

1999-08-08  Kresten Krab Thorup  <krab@gnu.org>

        * configure.in (--with-interpreter): Added.
        * include/config.h.in (INTERPRETER): Added.

        * java/lang/ClassLoader.java: File replaced.
        * java/lang/VMClassLoader.java: New file.
        * java/lang/natClassLoader.cc: New file.
        * gnu/gcj/runtime/MethodInvocation.java: New file.
        * gnu/gcj/util/path/SearchPath.java: New file.
        * gnu/gcj/util/path/PathEntry.java: New file.
        * gnu/gcj/util/path/DirectoryPathEntry.java: New file.
        * gnu/gcj/util/path/ZipPathEntry.java: New file.
        * gnu/gcj/util/path/URLPathEntry.java: New file.
        * gnu/gcj/util/path/CacheEntry.java: New file.
        * include/java-interp.h: New file.
        * include/java-cpool.h: New file.
        * include/java-insns.h: New file.
        * defineclass.cc: New file.
        * interpret.cc: New file.
        * resolve.cc: New file.

        * java/lang/natClass.cc (loaded_classes, _Jv_RegisterClass,
        _Jv_RegisterClasses, _Jv_FindClassInCache, _Jv_FindClass,
        _Jv_NewClass, _Jv_FindArrayClass): Moved to natClassLoader.cc.
        (finalize): New.
        (STATE_NOTHING, STATE_RESOLVED, STATE_IN_PROGRESS, STATE_DONE,
        STATE_ERROR): Moved to java/lang/Class.h and renamed with JV_
        prefix.
        (initializeClass): Use new JV_ prefixed names.  Also, call
        ClassLoader::resolveClass instead of _Jv_ResolveClass.

        * java/lang/Class.h (JV_STATE_PRELOADING, JV_STATE_LOADING,
        JV_STATE_LOADED, JV_STATE_COMPILED, JV_STATE_PREPARED,
        JV_STATE_LINKED): New.
        (_Jv_WaitForState, _Jv_RegisterInitiatingLoader,
        _Jv_UnregisterClass, _Jv_InternClassStrings): New friends.
        (_Jv_IsInterpretedClass, _Jv_InitField, _Jv_LookupDeclaredMethod,
        _Jv_DetermineVTableIndex, _Jv_ResolvePoolEntry, _Jv_PrepareClass,
        _Jv_ClassReader, _Jv_InterpClass, _Jv_InterpMethod,
        _Jv_InterpMethodInvocation): New friends for interpreter.
        (finalize): New.
        (CONSTANT_Class, CONSTANT_String, etc.): Moved to
        include/java-cpool.h and renamed with JV_ prefix.

        * include/jvm.h (_Jv_makeUtf8Const, _Jv_makeUtf8TypeConst): New
        decls.
        (_Jv_UnregisterClass): New decl.

        * java/lang/natClassLoader.cc (_Jv_FindArrayClass): Added
        class loader argument.
        (_Jv_FindClass): Use class loader.

        * prims.cc (_Jv_makeUtf8Const): New function.
        (_Jv_NewObjectArray): Change use of _Jv_FindArrayClass.
        (_Jv_NewPrimArray): Ditto.
        (_Jv_FindClassFromSignature): Ditto.
        * java/lang/reflect/natArray.cc (newInstance): Ditto.
        * java/lang/reflect/natMethod.cc (getType): Ditto.

        * include/java-field.h (_Jv_Field::isRef): Make robust for
        non-resolved contexts.

        * boehm.cc (_Jv_MarkObj): Mark interpreter-related fields.
        Also, don't mark class->next field.

        * java/lang/VirtualMachineError.java: Added FIXME note.

        * configure.in (INTERPSPEC): New spec.
        * libgcj.spec.in: Added INTERPSPEC.
        * Makefile.am: Added gcjh friends for java/lang/VMClassLoader and
        gnu/gcj/runtime/MethodInvocation.
        (libgcj_la_SOURCES): Added resolve.cc defineclass.cc interpret.cc.
        (ordinary_java_source_files): Added above mentioned java classes.

        * configure: Rebuilt.
        * Makefile.in: Rebuilt.

From-SVN: r28597

1 files changed, 76 insertions, 2 deletions

diff --git a/libjava/boehm.cc b/libjava/boehm.cc
index f9e72ba..2e1b5f2 100644
--- a/libjava/boehm.cc
+++ b/libjava/boehm.cc
@@ -16,6 +16,7 @@ details.  */
 #include <java/lang/Class.h>
 #include <jvm.h>
 #include <java-field.h>
+#include <java-interp.h>
 
 // We need to include gc_priv.h.  However, it tries to include
 // config.h if it hasn't already been included.  So we force the
@@ -97,8 +98,14 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/)
     {
       jclass c = (jclass) addr;
 
+#if 0
+      // The next field should probably not be marked, since this is
+      // only used in the class hash table.  Marking this field
+      // basically prohibits class unloading. --Kresten
       w = (word) c->next;
       MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c2label);
+#endif
+
       w = (word) c->name;
       MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c3label);
       w = (word) c->superclass;
@@ -109,12 +116,23 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/)
 	  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5label);
 	}
 
+#ifdef INTERPRETER
+      if (_Jv_IsInterpretedClass (c))
+	{
+	  w = (word) c->constants.tags;
+	  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5alabel);
+	  w = (word) c->constants.data;
+	  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5blabel);
+	}
+#endif
+
       // If the class is an array, then the methods field holds a
       // pointer to the element class.  If the class is primitive,
       // then the methods field holds a pointer to the array class.
       w = (word) c->methods;
       MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c6label);
 
+
       if (! c->isArray() && ! c->isPrimitive())
 	{
 	  // Scan each method in the cases where `methods' really
@@ -127,7 +145,19 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/)
 	      w = (word) c->methods[i].signature;
 	      MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c,
 			     cm2label);
+
 	      // FIXME: `ncode' entry?
+
+#ifdef INTERPRETER
+	      // The interpreter installs a heap-allocated
+	      // trampoline here, so we'll mark it. 
+	      if (_Jv_IsInterpretedClass (c))
+		  {
+		      w = (word) c->methods[i].ncode;
+		      MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c,
+				  cm3label);
+		  }
+#endif
 	    }
 	}
 
@@ -136,12 +166,34 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/)
       MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8label);
       for (int i = 0; i < c->field_count; ++i)
 	{
+	  _Jv_Field* field = &c->fields[i];
+
 #ifndef COMPACT_FIELDS
-	  w = (word) c->fields[i].name;
+	  w = (word) field->name;
 	  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8alabel);
 #endif
-	  w = (word) c->fields[i].type;
+	  w = (word) field->type;
 	  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8blabel);
+
+	  // For the interpreter, we also need to mark the memory
+	  // containing static members
+	  if (field->flags & 0x0008)
+	    {
+	      w = (word) field->u.addr;
+	      MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8clabel);
+
+	      // also, if the static member is a reference,
+	      // mark also the value pointed to.  We check for isResolved
+	      // since marking can happen before memory is allocated for
+	      // static members.
+	      if (JvFieldIsRef (field) && field->isResolved()) 
+		{
+		  jobject val = *(jobject*) field->u.addr;
+		  w = (word) val;
+		  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit,
+			      c, c8elabel);
+		}
+	    }
 	}
 
       w = (word) c->vtable;
@@ -155,6 +207,28 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/)
 	}
       w = (word) c->loader;
       MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cBlabel);
+
+#ifdef INTERPRETER
+      if (_Jv_IsInterpretedClass (c))
+	{
+	  _Jv_InterpClass* ic = (_Jv_InterpClass*)c;
+
+	  w = (word) ic->interpreted_methods;
+	  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, ic, cElabel);
+
+	  for (int i = 0; i < c->method_count; i++)
+	    {
+	      w = (word) ic->interpreted_methods[i];
+	      MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, ic, \
+			  cFlabel);
+	    }
+
+	  w = (word) ic->field_initializers;
+	  MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, ic, cGlabel);
+	  
+	}
+#endif
+
     }
   else
     {