X-Git-Url: http://wien.tomnetworks.com/gitweb/?p=hs-boehmgc.git;a=blobdiff_plain;f=gc-7.2%2Fgcj_mlc.c;fp=gc-7.2%2Fgcj_mlc.c;h=3467a39649e70645a823e9819dc87c930f80768d;hp=0000000000000000000000000000000000000000;hb=324587ba93dc77f37406d41fd2a20d0e0d94fb1d;hpb=2a4ea609491b225a1ceb06da70396e93916f137a diff --git a/gc-7.2/gcj_mlc.c b/gc-7.2/gcj_mlc.c new file mode 100644 index 0000000..3467a39 --- /dev/null +++ b/gc-7.2/gcj_mlc.c @@ -0,0 +1,278 @@ +/* + * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. + * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +#include "private/gc_pmark.h" /* includes gc_priv.h */ + +#ifdef GC_GCJ_SUPPORT + +/* + * This is an allocator interface tuned for gcj (the GNU static + * java compiler). + * + * Each allocated object has a pointer in its first word to a vtable, + * which for our purposes is simply a structure describing the type of + * the object. + * This descriptor structure contains a GC marking descriptor at offset + * MARK_DESCR_OFFSET. + * + * It is hoped that this interface may also be useful for other systems, + * possibly with some tuning of the constants. But the immediate goal + * is to get better gcj performance. + * + * We assume: + * 1) Counting on explicit initialization of this interface is OK; + * 2) FASTLOCK is not a significant win. + */ + +#include "gc_gcj.h" +#include "private/dbg_mlc.h" + +#ifdef GC_ASSERTIONS + GC_INNER /* variable is also used in thread_local_alloc.c */ +#else + STATIC +#endif +GC_bool GC_gcj_malloc_initialized = FALSE; + +int GC_gcj_kind = 0; /* Object kind for objects with descriptors */ + /* in "vtable". */ +int GC_gcj_debug_kind = 0; + /* The kind of objects that is always marked */ + /* with a mark proc call. */ + +GC_INNER ptr_t * GC_gcjobjfreelist = NULL; + +STATIC ptr_t * GC_gcjdebugobjfreelist = NULL; + +/*ARGSUSED*/ +STATIC struct GC_ms_entry * GC_gcj_fake_mark_proc(word * addr, + struct GC_ms_entry *mark_stack_ptr, + struct GC_ms_entry *mark_stack_limit, + word env) +{ + ABORT("No client gcj mark proc is specified"); + return mark_stack_ptr; +} + +/* Caller does not hold allocation lock. */ +GC_API void GC_CALL GC_init_gcj_malloc(int mp_index, + void * /* really GC_mark_proc */mp) +{ + GC_bool ignore_gcj_info; + DCL_LOCK_STATE; + + if (mp == 0) /* In case GC_DS_PROC is unused. */ + mp = (void *)(word)GC_gcj_fake_mark_proc; + + GC_init(); /* In case it's not already done. */ + LOCK(); + if (GC_gcj_malloc_initialized) { + UNLOCK(); + return; + } + GC_gcj_malloc_initialized = TRUE; +# ifdef GC_IGNORE_GCJ_INFO + /* This is useful for debugging on platforms with missing getenv(). */ + ignore_gcj_info = 1; +# else + ignore_gcj_info = (0 != GETENV("GC_IGNORE_GCJ_INFO")); +# endif + if (GC_print_stats && ignore_gcj_info) { + GC_log_printf("Gcj-style type information is disabled!\n"); + } + GC_ASSERT(GC_mark_procs[mp_index] == (GC_mark_proc)0); /* unused */ + GC_mark_procs[mp_index] = (GC_mark_proc)(word)mp; + if ((unsigned)mp_index >= GC_n_mark_procs) + ABORT("GC_init_gcj_malloc: bad index"); + /* Set up object kind gcj-style indirect descriptor. */ + GC_gcjobjfreelist = (ptr_t *)GC_new_free_list_inner(); + if (ignore_gcj_info) { + /* Use a simple length-based descriptor, thus forcing a fully */ + /* conservative scan. */ + GC_gcj_kind = GC_new_kind_inner((void **)GC_gcjobjfreelist, + (0 | GC_DS_LENGTH), + TRUE, TRUE); + } else { + GC_gcj_kind = GC_new_kind_inner( + (void **)GC_gcjobjfreelist, + (((word)(-(signed_word)MARK_DESCR_OFFSET + - GC_INDIR_PER_OBJ_BIAS)) + | GC_DS_PER_OBJECT), + FALSE, TRUE); + } + /* Set up object kind for objects that require mark proc call. */ + if (ignore_gcj_info) { + GC_gcj_debug_kind = GC_gcj_kind; + GC_gcjdebugobjfreelist = GC_gcjobjfreelist; + } else { + GC_gcjdebugobjfreelist = (ptr_t *)GC_new_free_list_inner(); + GC_gcj_debug_kind = GC_new_kind_inner( + (void **)GC_gcjdebugobjfreelist, + GC_MAKE_PROC(mp_index, + 1 /* allocated with debug info */), + FALSE, TRUE); + } + UNLOCK(); +} + +#define GENERAL_MALLOC_INNER(lb,k) \ + GC_clear_stack(GC_generic_malloc_inner(lb, k)) + +#define GENERAL_MALLOC_INNER_IOP(lb,k) \ + GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k)) + +/* We need a mechanism to release the lock and invoke finalizers. */ +/* We don't really have an opportunity to do this on a rarely executed */ +/* path on which the lock is not held. Thus we check at a */ +/* rarely executed point at which it is safe to release the lock. */ +/* We do this even where we could just call GC_INVOKE_FINALIZERS, */ +/* since it's probably cheaper and certainly more uniform. */ +/* FIXME - Consider doing the same elsewhere? */ +static void maybe_finalize(void) +{ + static word last_finalized_no = 0; + DCL_LOCK_STATE; + + if (GC_gc_no == last_finalized_no) return; + if (!GC_is_initialized) return; + UNLOCK(); + GC_INVOKE_FINALIZERS(); + LOCK(); + last_finalized_no = GC_gc_no; +} + +/* Allocate an object, clear it, and store the pointer to the */ +/* type structure (vtable in gcj). */ +/* This adds a byte at the end of the object if GC_malloc would.*/ +#ifdef THREAD_LOCAL_ALLOC + GC_INNER void * GC_core_gcj_malloc(size_t lb, + void * ptr_to_struct_containing_descr) +#else + GC_API void * GC_CALL GC_gcj_malloc(size_t lb, + void * ptr_to_struct_containing_descr) +#endif +{ + ptr_t op; + ptr_t * opp; + word lg; + DCL_LOCK_STATE; + + if(SMALL_OBJ(lb)) { + lg = GC_size_map[lb]; + opp = &(GC_gcjobjfreelist[lg]); + LOCK(); + op = *opp; + if(EXPECT(op == 0, FALSE)) { + maybe_finalize(); + op = (ptr_t)GENERAL_MALLOC_INNER((word)lb, GC_gcj_kind); + if (0 == op) { + GC_oom_func oom_fn = GC_oom_fn; + UNLOCK(); + return((*oom_fn)(lb)); + } + } else { + *opp = obj_link(op); + GC_bytes_allocd += GRANULES_TO_BYTES(lg); + } + *(void **)op = ptr_to_struct_containing_descr; + GC_ASSERT(((void **)op)[1] == 0); + UNLOCK(); + } else { + LOCK(); + maybe_finalize(); + op = (ptr_t)GENERAL_MALLOC_INNER((word)lb, GC_gcj_kind); + if (0 == op) { + GC_oom_func oom_fn = GC_oom_fn; + UNLOCK(); + return((*oom_fn)(lb)); + } + *(void **)op = ptr_to_struct_containing_descr; + UNLOCK(); + } + return((void *) op); +} + +/* Similar to GC_gcj_malloc, but add debug info. This is allocated */ +/* with GC_gcj_debug_kind. */ +GC_API void * GC_CALL GC_debug_gcj_malloc(size_t lb, + void * ptr_to_struct_containing_descr, GC_EXTRA_PARAMS) +{ + void * result; + DCL_LOCK_STATE; + + /* We're careful to avoid extra calls, which could */ + /* confuse the backtrace. */ + LOCK(); + maybe_finalize(); + result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind); + if (result == 0) { + GC_oom_func oom_fn = GC_oom_fn; + UNLOCK(); + GC_err_printf("GC_debug_gcj_malloc(%ld, %p) returning NULL (", + (unsigned long)lb, ptr_to_struct_containing_descr); + GC_err_puts(s); + GC_err_printf(":%d)\n", i); + return((*oom_fn)(lb)); + } + *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr; + UNLOCK(); + if (!GC_debugging_started) { + GC_start_debugging(); + } + ADD_CALL_CHAIN(result, ra); + return (GC_store_debug_info(result, (word)lb, s, i)); +} + +/* There is no THREAD_LOCAL_ALLOC for GC_gcj_malloc_ignore_off_page(). */ +GC_API void * GC_CALL GC_gcj_malloc_ignore_off_page(size_t lb, + void * ptr_to_struct_containing_descr) +{ + ptr_t op; + ptr_t * opp; + word lg; + DCL_LOCK_STATE; + + if(SMALL_OBJ(lb)) { + lg = GC_size_map[lb]; + opp = &(GC_gcjobjfreelist[lg]); + LOCK(); + if( (op = *opp) == 0 ) { + maybe_finalize(); + op = (ptr_t)GENERAL_MALLOC_INNER_IOP(lb, GC_gcj_kind); + if (0 == op) { + GC_oom_func oom_fn = GC_oom_fn; + UNLOCK(); + return((*oom_fn)(lb)); + } + } else { + *opp = obj_link(op); + GC_bytes_allocd += GRANULES_TO_BYTES(lg); + } + } else { + LOCK(); + maybe_finalize(); + op = (ptr_t)GENERAL_MALLOC_INNER_IOP(lb, GC_gcj_kind); + if (0 == op) { + GC_oom_func oom_fn = GC_oom_fn; + UNLOCK(); + return((*oom_fn)(lb)); + } + } + *(void **)op = ptr_to_struct_containing_descr; + UNLOCK(); + return((void *) op); +} + +#endif /* GC_GCJ_SUPPORT */