2 * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
3 * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
5 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
6 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
8 * Permission is hereby granted to use or copy this program
9 * for any purpose, provided the above notices are retained on all copies.
10 * Permission to modify the code and to distribute modified code is granted,
11 * provided the above notices are retained, and a notice that the code was
12 * modified is included with the above copyright notice.
15 /* Boehm, July 31, 1995 5:02 pm PDT */
18 * This is an allocator interface tuned for gcj (the GNU static
21 * Each allocated object has a pointer in its first word to a vtable,
22 * which for our purposes is simply a structure describing the type of
24 * This descriptor structure contains a GC marking descriptor at offset
27 * It is hoped that this interface may also be useful for other systems,
28 * possibly with some tuning of the constants. But the immediate goal
29 * is to get better gcj performance.
32 * 1) We have an ANSI conforming C compiler.
33 * 2) Counting on explicit initialization of this interface is OK.
34 * 3) FASTLOCK is not a significant win.
37 #include "private/gc_pmark.h"
39 #include "private/dbg_mlc.h"
43 GC_bool GC_gcj_malloc_initialized = FALSE;
45 int GC_gcj_kind; /* Object kind for objects with descriptors */
47 int GC_gcj_debug_kind; /* The kind of objects that is always marked */
48 /* with a mark proc call. */
50 ptr_t * GC_gcjobjfreelist;
51 ptr_t * GC_gcjdebugobjfreelist;
53 /* Caller does not hold allocation lock. */
54 void GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp)
57 GC_bool ignore_gcj_info;
60 GC_init(); /* In case it's not already done. */
63 if (GC_gcj_malloc_initialized) {
68 GC_gcj_malloc_initialized = TRUE;
69 ignore_gcj_info = (0 != GETENV("GC_IGNORE_GCJ_INFO"));
71 if (GC_print_stats && ignore_gcj_info) {
72 GC_printf0("Gcj-style type information is disabled!\n");
75 GC_ASSERT(GC_mark_procs[mp_index] == (GC_mark_proc)0); /* unused */
76 GC_mark_procs[mp_index] = (GC_mark_proc)mp;
77 if (mp_index >= GC_n_mark_procs) ABORT("GC_init_gcj_malloc: bad index");
78 /* Set up object kind gcj-style indirect descriptor. */
79 GC_gcjobjfreelist = (ptr_t *)GC_new_free_list_inner();
80 if (ignore_gcj_info) {
81 /* Use a simple length-based descriptor, thus forcing a fully */
82 /* conservative scan. */
83 GC_gcj_kind = GC_new_kind_inner((void **)GC_gcjobjfreelist,
87 GC_gcj_kind = GC_new_kind_inner(
88 (void **)GC_gcjobjfreelist,
89 (((word)(-MARK_DESCR_OFFSET - GC_INDIR_PER_OBJ_BIAS))
93 /* Set up object kind for objects that require mark proc call. */
94 if (ignore_gcj_info) {
95 GC_gcj_debug_kind = GC_gcj_kind;
96 GC_gcjdebugobjfreelist = GC_gcjobjfreelist;
98 GC_gcjdebugobjfreelist = (ptr_t *)GC_new_free_list_inner();
99 GC_gcj_debug_kind = GC_new_kind_inner(
100 (void **)GC_gcjdebugobjfreelist,
101 GC_MAKE_PROC(mp_index,
102 1 /* allocated with debug info */),
109 ptr_t GC_clear_stack();
111 #define GENERAL_MALLOC(lb,k) \
112 (GC_PTR)GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
114 #define GENERAL_MALLOC_IOP(lb,k) \
115 (GC_PTR)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))
117 /* We need a mechanism to release the lock and invoke finalizers. */
118 /* We don't really have an opportunity to do this on a rarely executed */
119 /* path on which the lock is not held. Thus we check at a */
120 /* rarely executed point at which it is safe to release the lock. */
121 /* We do this even where we could just call GC_INVOKE_FINALIZERS, */
122 /* since it's probably cheaper and certainly more uniform. */
123 /* FIXME - Consider doing the same elsewhere? */
124 static void maybe_finalize()
126 static int last_finalized_no = 0;
128 if (GC_gc_no == last_finalized_no) return;
129 if (!GC_is_initialized) return;
131 GC_INVOKE_FINALIZERS();
132 last_finalized_no = GC_gc_no;
136 /* Allocate an object, clear it, and store the pointer to the */
137 /* type structure (vtable in gcj). */
138 /* This adds a byte at the end of the object if GC_malloc would.*/
139 void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr)
142 register ptr_t * opp;
146 if( EXPECT(SMALL_OBJ(lb), 1) ) {
148 lw = GC_size_map[lb];
150 lw = ALIGNED_WORDS(lb);
152 opp = &(GC_gcjobjfreelist[lw]);
155 if(EXPECT(op == 0, 0)) {
157 op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
160 return(GC_oom_fn(lb));
163 lw = GC_size_map[lb]; /* May have been uninitialized. */
167 GC_words_allocd += lw;
169 *(void **)op = ptr_to_struct_containing_descr;
170 GC_ASSERT(((void **)op)[1] == 0);
175 op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
178 return(GC_oom_fn(lb));
180 *(void **)op = ptr_to_struct_containing_descr;
186 /* Similar to GC_gcj_malloc, but add debug info. This is allocated */
187 /* with GC_gcj_debug_kind. */
188 GC_PTR GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
193 /* We're careful to avoid extra calls, which could */
194 /* confuse the backtrace. */
197 result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
200 GC_err_printf2("GC_debug_gcj_malloc(%ld, 0x%lx) returning NIL (",
202 (unsigned long) ptr_to_struct_containing_descr);
204 GC_err_printf1(":%ld)\n", (unsigned long)i);
205 return(GC_oom_fn(lb));
207 *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
209 if (!GC_debugging_started) {
210 GC_start_debugging();
212 ADD_CALL_CHAIN(result, ra);
213 return (GC_store_debug_info(result, (word)lb, s, (word)i));
216 /* Similar to GC_gcj_malloc, but the size is in words, and we don't */
217 /* adjust it. The size is assumed to be such that it can be */
218 /* allocated as a small object. */
219 void * GC_gcj_fast_malloc(size_t lw, void * ptr_to_struct_containing_descr)
225 opp = &(GC_gcjobjfreelist[lw]);
228 if( EXPECT(op == 0, 0) ) {
230 op = (ptr_t)GC_clear_stack(
231 GC_generic_malloc_words_small_inner(lw, GC_gcj_kind));
234 return GC_oom_fn(WORDS_TO_BYTES(lw));
238 GC_words_allocd += lw;
240 *(void **)op = ptr_to_struct_containing_descr;
245 /* And a debugging version of the above: */
246 void * GC_debug_gcj_fast_malloc(size_t lw,
247 void * ptr_to_struct_containing_descr,
251 size_t lb = WORDS_TO_BYTES(lw);
253 /* We clone the code from GC_debug_gcj_malloc, so that we */
254 /* dont end up with extra frames on the stack, which could */
255 /* confuse the backtrace. */
258 result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
261 GC_err_printf2("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (",
263 (unsigned long) ptr_to_struct_containing_descr);
265 GC_err_printf1(":%ld)\n", (unsigned long)i);
266 return GC_oom_fn(WORDS_TO_BYTES(lw));
268 *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
270 if (!GC_debugging_started) {
271 GC_start_debugging();
273 ADD_CALL_CHAIN(result, ra);
274 return (GC_store_debug_info(result, (word)lb, s, (word)i));
277 void * GC_gcj_malloc_ignore_off_page(size_t lb,
278 void * ptr_to_struct_containing_descr)
281 register ptr_t * opp;
285 if( SMALL_OBJ(lb) ) {
287 lw = GC_size_map[lb];
289 lw = ALIGNED_WORDS(lb);
291 opp = &(GC_gcjobjfreelist[lw]);
293 if( (op = *opp) == 0 ) {
295 op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
297 lw = GC_size_map[lb]; /* May have been uninitialized. */
301 GC_words_allocd += lw;
303 *(void **)op = ptr_to_struct_containing_descr;
308 op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
310 *(void **)op = ptr_to_struct_containing_descr;
319 char GC_no_gcj_support;
321 #endif /* GC_GCJ_SUPPORT */