From f20fe604499aca5125597268deecab241fc55e95 Mon Sep 17 00:00:00 2001 From: aoliva Date: Wed, 7 Mar 2007 07:27:25 +0000 Subject: libffi/ChangeLog: * include/ffi.h.in (ffi_closure_alloc, ffi_closure_free): New. (ffi_prep_closure_loc): New. (ffi_prep_raw_closure_loc): New. (ffi_prep_java_raw_closure_loc): New. * src/closures.c: New file. * src/dlmalloc.c [FFI_MMAP_EXEC_WRIT] (struct malloc_segment): Replace sflags with exec_offset. [FFI_MMAP_EXEC_WRIT] (mmap_exec_offset, add_segment_exec_offset, sub_segment_exec_offset): New macros. (get_segment_flags, set_segment_flags, check_segment_merge): New macros. (is_mmapped_segment, is_extern_segment): Use get_segment_flags. (add_segment, sys_alloc, create_mspace, create_mspace_with_base, destroy_mspace): Use new macros. (sys_alloc): Silence warning. * Makefile.am (libffi_la_SOURCES): Add src/closures.c. * Makefile.in: Rebuilt. * src/prep_cif [FFI_CLOSURES] (ffi_prep_closure): Implement in terms of ffi_prep_closure_loc. * src/raw_api.c (ffi_prep_raw_closure_loc): Renamed and adjusted from... (ffi_prep_raw_closure): ... this. Re-implement in terms of the renamed version. * src/java_raw_api (ffi_prep_java_raw_closure_loc): Renamed and adjusted from... (ffi_prep_java_raw_closure): ... this. Re-implement in terms of the renamed version. * src/alpha/ffi.c (ffi_prep_closure_loc): Renamed from (ffi_prep_closure): ... this. * src/pa/ffi.c: Likewise. * src/cris/ffi.c: Likewise. Adjust. * src/frv/ffi.c: Likewise. * src/ia64/ffi.c: Likewise. * src/mips/ffi.c: Likewise. * src/powerpc/ffi_darwin.c: Likewise. * src/s390/ffi.c: Likewise. * src/sh/ffi.c: Likewise. * src/sh64/ffi.c: Likewise. * src/sparc/ffi.c: Likewise. * src/x86/ffi64.c: Likewise. * src/x86/ffi.c: Likewise. (FFI_INIT_TRAMPOLINE): Adjust. (ffi_prep_raw_closure_loc): Renamed and adjusted from... (ffi_prep_raw_closure): ... this. * src/powerpc/ffi.c (ffi_prep_closure_loc): Renamed from (ffi_prep_closure): ... this. (flush_icache): Adjust. boehm-gc/ChangeLog: * include/gc.h (GC_REGISTER_FINALIZER_UNREACHABLE): New. (GC_register_finalizer_unreachable): Declare. (GC_debug_register_finalizer_unreachable): Declare. * finalize.c (GC_unreachable_finalize_mark_proc): New. (GC_register_finalizer_unreachable): New. (GC_finalize): Handle it. * dbg_mlc.c (GC_debug_register_finalizer_unreachable): New. (GC_debug_register_finalizer_no_order): Fix whitespace. libjava/ChangeLog: * include/jvm.h (_Jv_ClosureListFinalizer): New. (_Jv_Linker::create_error_method): Adjust. * boehm.cc (_Jv_ClosureListFinalizer): New. * nogc.cc (_Jv_ClosureListFinalizer): New. * java/lang/Class.h (class _Jv_ClosureList): New. (class java::lang::Class): Declare it as friend. * java/lang/natClass.cc (_Jv_ClosureList::releaseClosures): New. (_Jv_ClosureList::registerClousure): New. * include/execution.h (_Jv_ExecutionEngine): Add get_closure_list. (_Jv_CompiledEngine::do_get_closure_list): New. (_Jv_CompiledEngine::_Jv_CompiledEngine): Use it. (_Jv_IndirectCompiledClass): Add closures. (_Jv_IndirectCompiledEngine::get_aux_info): New. (_Jv_IndirectCompiledEngine::do_allocate_field_initializers): Use it. (_Jv_IndirectCompiledEngine::do_get_closure_list): New. (_Jv_IndirectCompiledEngine::_Jv_IndirectCompiledEngine): Use it. (_Jv_InterpreterEngine::do_get_closure_list): Declare. (_Jv_InterpreterEngine::_Jv_InterpreterEngine): Use it. * interpret.cc (FFI_PREP_RAW_CLOSURE): Use _loc variants. (node_closure): Add closure list. (_Jv_InterpMethod::ncode): Add jclass argument. Use ffi_closure_alloc and the separate code pointer. Register the closure for finalization. (_Jv_JNIMethod::ncode): Likewise. (_Jv_InterpreterEngine::do_create_ncode): Pass klass to ncode. (_Jv_InterpreterEngine::do_get_closure_list): New. * include/java-interp.h (_Jv_InterpMethod::ncode): Adjust. (_Jv_InterpClass): Add closures field. (_Jv_JNIMethod::ncode): Adjust. * defineclass.cc (_Jv_ClassReader::handleCodeAttribute): Adjust. (_Jv_ClassReader::handleMethodsEnd): Likewise. * link.cc (struct method_closure): Add closure list. (_Jv_Linker::create_error_method): Add jclass argument. Use ffi_closure_alloc and the separate code pointer. Register the closure for finalization. (_Jv_Linker::link_symbol_table): Remove outdated comment about sharing of otable and atable. Adjust. * java/lang/reflect/natVMProxy.cc (ncode_closure): Add closure list. (ncode): Add jclass argument. Use ffi_closure_alloc and the separate code pointer. Register the closure for finalization. (java::lang::reflect::VMProxy::generateProxyClass): Adjust. * testsuite/libjava.jar/TestClosureGC.java: New. * testsuite/libjava.jar/TestClosureGC.out: New. * testsuite/libjava.jar/TestClosureGC.xfail: New. * testsuite/libjava.jar/TestClosureGC.jar: New. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@122652 138bc75d-0d04-0410-961f-82ee72b054a4 --- libjava/java/lang/Class.h | 10 ++++++++++ libjava/java/lang/natClass.cc | 22 ++++++++++++++++++++++ libjava/java/lang/reflect/natVMProxy.cc | 27 ++++++++++++++++----------- 3 files changed, 48 insertions(+), 11 deletions(-) (limited to 'libjava/java') diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h index 3ea26ab85cf..80c410009ea 100644 --- a/libjava/java/lang/Class.h +++ b/libjava/java/lang/Class.h @@ -105,6 +105,15 @@ class _Jv_InterpClass; class _Jv_InterpMethod; #endif +class _Jv_ClosureList +{ + _Jv_ClosureList *next; + void *ptr; +public: + void registerClosure (jclass klass, void *ptr); + static void releaseClosures (_Jv_ClosureList **closures); +}; + struct _Jv_Constants { jint size; @@ -632,6 +641,7 @@ private: friend class ::_Jv_CompiledEngine; friend class ::_Jv_IndirectCompiledEngine; friend class ::_Jv_InterpreterEngine; + friend class ::_Jv_ClosureList; friend void ::_Jv_sharedlib_register_hook (jclass klass); diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc index cec519fd502..79fa59989d3 100644 --- a/libjava/java/lang/natClass.cc +++ b/libjava/java/lang/natClass.cc @@ -670,6 +670,28 @@ java::lang::Class::finalize (void) engine->unregister(this); } +void +_Jv_ClosureList::releaseClosures (_Jv_ClosureList **closures) +{ + if (!closures) + return; + + while (_Jv_ClosureList *current = *closures) + { + *closures = current->next; + ffi_closure_free (current->ptr); + } +} + +void +_Jv_ClosureList::registerClosure (jclass klass, void *ptr) +{ + _Jv_ClosureList **closures = klass->engine->get_closure_list (klass); + this->ptr = ptr; + this->next = *closures; + *closures = this; +} + // This implements the initialization process for a class. From Spec // section 12.4.2. void diff --git a/libjava/java/lang/reflect/natVMProxy.cc b/libjava/java/lang/reflect/natVMProxy.cc index c83880ccf1e..5704049909a 100644 --- a/libjava/java/lang/reflect/natVMProxy.cc +++ b/libjava/java/lang/reflect/natVMProxy.cc @@ -1,6 +1,6 @@ // natVMProxy.cc -- Implementation of VMProxy methods. -/* Copyright (C) 2006 +/* Copyright (C) 2006, 2007 Free Software Foundation This file is part of libgcj. @@ -66,7 +66,7 @@ using namespace java::lang::reflect; using namespace java::lang; typedef void (*closure_fun) (ffi_cif*, void*, void**, void*); -static void *ncode (_Jv_Method *self, closure_fun fun); +static void *ncode (jclass klass, _Jv_Method *self, closure_fun fun); static void run_proxy (ffi_cif*, void*, void**, void*); typedef jobject invoke_t (jobject, Proxy *, Method *, JArray< jobject > *); @@ -165,7 +165,7 @@ java::lang::reflect::VMProxy::generateProxyClass // the interfaces of which it is a proxy will also be reachable, // so this is safe. method = imethod; - method.ncode = ncode (&method, run_proxy); + method.ncode = ncode (klass, &method, run_proxy); method.accflags &= ~Modifier::ABSTRACT; } @@ -289,6 +289,7 @@ unbox (jobject o, jclass klass, void *rvalue, FFI_TYPE type) typedef struct { ffi_closure closure; + _Jv_ClosureList list; ffi_cif cif; _Jv_Method *self; ffi_type *arg_types[0]; @@ -366,16 +367,19 @@ run_proxy (ffi_cif *cif, // the address of its closure. static void * -ncode (_Jv_Method *self, closure_fun fun) +ncode (jclass klass, _Jv_Method *self, closure_fun fun) { using namespace java::lang::reflect; jboolean staticp = (self->accflags & Modifier::STATIC) != 0; int arg_count = _Jv_count_arguments (self->signature, staticp); + void *code; ncode_closure *closure = - (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure) - + arg_count * sizeof (ffi_type*)); + (ncode_closure*)ffi_closure_alloc (sizeof (ncode_closure) + + arg_count * sizeof (ffi_type*), + &code); + closure->list.registerClosure (klass, closure); _Jv_init_cif (self->signature, arg_count, @@ -387,11 +391,12 @@ ncode (_Jv_Method *self, closure_fun fun) JvAssert ((self->accflags & Modifier::NATIVE) == 0); - ffi_prep_closure (&closure->closure, - &closure->cif, - fun, - (void*)closure); + ffi_prep_closure_loc (&closure->closure, + &closure->cif, + fun, + code, + code); - self->ncode = (void*)closure; + self->ncode = code; return self->ncode; } -- cgit v1.2.3