From 58eb6e7cef1cea515f8da18d24341a4aa53ccb70 Mon Sep 17 00:00:00 2001 From: Anthony Green Date: Sun, 8 Aug 1999 14:06:23 +0000 Subject: [multiple changes] 1999-08-09 Anthony Green * 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 * 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 * 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 --- libjava/boehm.cc | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 76 insertions(+), 2 deletions(-) (limited to 'libjava/boehm.cc') 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 #include #include +#include // 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 { -- cgit v1.1