Annotation of OpenXM_contrib/gc/gcj_mlc.c, Revision 1.1.1.1
1.1 maekawa 1: /*
2: * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
3: * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
4: *
5: * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
6: * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
7: *
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.
13: *
14: */
15: /* Boehm, July 31, 1995 5:02 pm PDT */
16:
17: #ifdef GC_GCJ_SUPPORT
18:
19: /*
20: * This is an allocator interface tuned for gcj (the GNU/Cygnus static
21: * java compiler).
22: *
23: * Each allocated object has a pointer in its first word to a vtable,
24: * which for our purposes is simply a structure describing the type of
25: * the object.
26: * This descriptor structur contains a GC marking descriptor at offset
27: * MARK_DESCR_OFFSET.
28: *
29: * It is hoped that this interface may also be useful for other systems,
30: * possibly with some tuning of the constants. But the immediate goal
31: * is to get better gcj performance.
32: *
33: * We assume:
34: * 1) We have an ANSI conforming C compiler.
35: * 2) Counting on explicit initialization of this interface is OK.
36: * 3) FASTLOCK is not a significant win.
37: */
38:
39: #include "gc_priv.h"
40: #include "gc_mark.h"
41: #include "include/gc_gcj.h"
42: #include "dbg_mlc.h"
43:
44: GC_bool GC_gcj_malloc_initialized = FALSE;
45:
46: int GC_gcj_kind; /* Object kind for objects with descriptors */
47: /* in "vtable". */
48: int GC_gcj_debug_kind; /* The kind of objects that is always marked */
49: /* with a mark proc call. */
50:
51: ptr_t * GC_gcjobjfreelist;
52: ptr_t * GC_gcjdebugobjfreelist;
53:
54: void * GC_default_oom_action(void) { return 0; }
55:
56: void * (*GC_oom_action)(void) = GC_default_oom_action;
57:
58: /* Caller does not hold allocation lock. */
59: void GC_init_gcj_malloc(int mp_index, void * /* really mark_proc */mp)
60: {
61: register int i;
62: DCL_LOCK_STATE;
63:
64: GC_init(); /* In case it's not already done. */
65: DISABLE_SIGNALS();
66: LOCK();
67: if (GC_gcj_malloc_initialized) {
68: UNLOCK();
69: ENABLE_SIGNALS();
70: return;
71: }
72: GC_gcj_malloc_initialized = TRUE;
73: GC_mark_procs[mp_index] = (mark_proc)mp;
74: if (mp_index >= GC_n_mark_procs) ABORT("GC_init_gcj_malloc: bad index");
75: /* Set up object kind gcj-style indirect descriptor. */
76: GC_gcjobjfreelist = (ptr_t *)
77: GC_generic_malloc_inner((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
78: if (GC_gcjobjfreelist == 0) ABORT("Couldn't allocate GC_gcjobjfreelist");
79: BZERO(GC_gcjobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
80: GC_gcj_kind = GC_n_kinds++;
81: GC_obj_kinds[GC_gcj_kind].ok_freelist = GC_gcjobjfreelist;
82: GC_obj_kinds[GC_gcj_kind].ok_reclaim_list = 0;
83: GC_obj_kinds[GC_gcj_kind].ok_descriptor =
84: (((word)(-MARK_DESCR_OFFSET - INDIR_PER_OBJ_BIAS)) | DS_PER_OBJECT);
85: GC_obj_kinds[GC_gcj_kind].ok_relocate_descr = FALSE;
86: GC_obj_kinds[GC_gcj_kind].ok_init = TRUE;
87: /* Set up object kind for objects that require mark proc call. */
88: GC_gcjdebugobjfreelist = (ptr_t *)
89: GC_generic_malloc_inner((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
90: if (GC_gcjdebugobjfreelist == 0)
91: ABORT("Couldn't allocate GC_gcjdebugobjfreelist");
92: BZERO(GC_gcjdebugobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
93: GC_gcj_debug_kind = GC_n_kinds++;
94: GC_obj_kinds[GC_gcj_debug_kind].ok_freelist = GC_gcjdebugobjfreelist;
95: GC_obj_kinds[GC_gcj_debug_kind].ok_reclaim_list = 0;
96: GC_obj_kinds[GC_gcj_debug_kind].ok_descriptor =
97: MAKE_PROC(mp_index, 1 /* allocated with debug info */);
98: GC_obj_kinds[GC_gcj_debug_kind].ok_relocate_descr = FALSE;
99: GC_obj_kinds[GC_gcj_debug_kind].ok_init = TRUE;
100: UNLOCK();
101: ENABLE_SIGNALS();
102: }
103:
104: ptr_t GC_clear_stack();
105:
106: #define GENERAL_MALLOC(lb,k) \
107: (GC_PTR)GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
108:
109: #define GENERAL_MALLOC_IOP(lb,k) \
110: (GC_PTR)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))
111:
112: /* Allocate an object, clear it, and store the pointer to the */
113: /* type structure (vtable in gcj). */
114: /* This adds a byte at the end of the object if GC_malloc would.*/
115: void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr)
116: {
117: register ptr_t op;
118: register ptr_t * opp;
119: register word lw;
120: DCL_LOCK_STATE;
121:
122: if( SMALL_OBJ(lb) ) {
123: # ifdef MERGE_SIZES
124: lw = GC_size_map[lb];
125: # else
126: lw = ALIGNED_WORDS(lb);
127: # endif
128: opp = &(GC_gcjobjfreelist[lw]);
129: LOCK();
130: if( (op = *opp) == 0 ) {
131: op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
132: if (0 == op) {
133: UNLOCK();
134: return(GC_oom_action());
135: }
136: # ifdef MERGE_SIZES
137: lw = GC_size_map[lb]; /* May have been uninitialized. */
138: # endif
139: } else {
140: *opp = obj_link(op);
141: GC_words_allocd += lw;
142: FASTUNLOCK();
143: }
144: *(void **)op = ptr_to_struct_containing_descr;
145: UNLOCK();
146: } else {
147: LOCK();
148: op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
149: if (0 == op) {
150: UNLOCK();
151: return(GC_oom_action());
152: }
153: *(void **)op = ptr_to_struct_containing_descr;
154: UNLOCK();
155: }
156: return((GC_PTR) op);
157: }
158:
159: /* Similar to GC_gcj_malloc, but add debug info. This is allocated */
160: /* with GC_gcj_debug_kind. */
161: GC_PTR GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
162: GC_EXTRA_PARAMS)
163: {
164: GC_PTR result;
165:
166: /* We clone the code from GC_debug_gcj_malloc, so that we */
167: /* dont end up with extra frames on the stack, which could */
168: /* confuse the backtrace. */
169: LOCK();
170: result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
171: if (result == 0) {
172: UNLOCK();
173: GC_err_printf2("GC_debug_gcj_malloc(%ld, 0x%lx) returning NIL (",
174: (unsigned long) lb,
175: (unsigned long) ptr_to_struct_containing_descr);
176: GC_err_puts(s);
177: GC_err_printf1(":%ld)\n", (unsigned long)i);
178: return(GC_oom_action());
179: }
180: *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
181: UNLOCK();
182: if (!GC_debugging_started) {
183: GC_start_debugging();
184: }
185: ADD_CALL_CHAIN(result, ra);
186: return (GC_store_debug_info(result, (word)lb, s, (word)i));
187: }
188:
189: /* Similar to GC_gcj_malloc, but the size is in words, and we don't */
190: /* adjust it. The size is assumed to be such that it can be */
191: /* allocated as a small object. */
192: void * GC_gcj_fast_malloc(size_t lw, void * ptr_to_struct_containing_descr)
193: {
194: ptr_t op;
195: ptr_t * opp;
196: DCL_LOCK_STATE;
197:
198: opp = &(GC_gcjobjfreelist[lw]);
199: LOCK();
200: if( (op = *opp) == 0 ) {
201: op = (ptr_t)GC_clear_stack(
202: GC_generic_malloc_words_small_inner(lw, GC_gcj_kind));
203: if (0 == op) {
204: UNLOCK();
205: return(GC_oom_action());
206: }
207: } else {
208: *opp = obj_link(op);
209: GC_words_allocd += lw;
210: }
211: *(void **)op = ptr_to_struct_containing_descr;
212: UNLOCK();
213: return((GC_PTR) op);
214: }
215:
216: /* And a debugging version of the above: */
217: void * GC_debug_gcj_fast_malloc(size_t lw,
218: void * ptr_to_struct_containing_descr,
219: GC_EXTRA_PARAMS)
220: {
221: GC_PTR result;
222: size_t lb = WORDS_TO_BYTES(lw);
223:
224: /* We clone the code from GC_debug_gcj_malloc, so that we */
225: /* dont end up with extra frames on the stack, which could */
226: /* confuse the backtrace. */
227: LOCK();
228: result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
229: if (result == 0) {
230: UNLOCK();
231: GC_err_printf2("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (",
232: (unsigned long) lw,
233: (unsigned long) ptr_to_struct_containing_descr);
234: GC_err_puts(s);
235: GC_err_printf1(":%ld)\n", (unsigned long)i);
236: return(GC_oom_action());
237: }
238: *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
239: UNLOCK();
240: if (!GC_debugging_started) {
241: GC_start_debugging();
242: }
243: ADD_CALL_CHAIN(result, ra);
244: return (GC_store_debug_info(result, (word)lb, s, (word)i));
245: }
246:
247: void * GC_gcj_malloc_ignore_off_page(size_t lb,
248: void * ptr_to_struct_containing_descr)
249: {
250: register ptr_t op;
251: register ptr_t * opp;
252: register word lw;
253: DCL_LOCK_STATE;
254:
255: if( SMALL_OBJ(lb) ) {
256: # ifdef MERGE_SIZES
257: lw = GC_size_map[lb];
258: # else
259: lw = ALIGNED_WORDS(lb);
260: # endif
261: opp = &(GC_gcjobjfreelist[lw]);
262: LOCK();
263: if( (op = *opp) == 0 ) {
264: op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
265: # ifdef MERGE_SIZES
266: lw = GC_size_map[lb]; /* May have been uninitialized. */
267: # endif
268: } else {
269: *opp = obj_link(op);
270: GC_words_allocd += lw;
271: FASTUNLOCK();
272: }
273: *(void **)op = ptr_to_struct_containing_descr;
274: UNLOCK();
275: } else {
276: op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
277: if (0 != op) {
278: *(void **)op = ptr_to_struct_containing_descr;
279: }
280: UNLOCK();
281: }
282: return((GC_PTR) op);
283: }
284:
285: #else
286:
287: char GC_no_gcj_support;
288:
289: #endif /* GC_GCJ_SUPPORT */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gcj_mlc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gc