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 */
20 * This is an allocator interface tuned for gcj (the GNU/Cygnus static
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
26 * This descriptor structur contains a GC marking descriptor at offset
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.
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.
41 #include "include/gc_gcj.h"
44 GC_bool GC_gcj_malloc_initialized
= FALSE
;
46 int GC_gcj_kind
; /* Object kind for objects with descriptors */
48 int GC_gcj_debug_kind
; /* The kind of objects that is always marked */
49 /* with a mark proc call. */
51 ptr_t
* GC_gcjobjfreelist
;
52 ptr_t
* GC_gcjdebugobjfreelist
;
54 void * GC_default_oom_action(void) { return 0; }
56 void * (*GC_oom_action
)(void) = GC_default_oom_action
;
58 /* Caller does not hold allocation lock. */
59 void GC_init_gcj_malloc(int mp_index
, void * /* really mark_proc */mp
)
64 GC_init(); /* In case it's not already done. */
67 if (GC_gcj_malloc_initialized
) {
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
;
104 ptr_t
GC_clear_stack();
106 #define GENERAL_MALLOC(lb,k) \
107 (GC_PTR)GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
109 #define GENERAL_MALLOC_IOP(lb,k) \
110 (GC_PTR)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))
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
)
118 register ptr_t
* opp
;
122 if( SMALL_OBJ(lb
) ) {
124 lw
= GC_size_map
[lb
];
126 lw
= ALIGNED_WORDS(lb
);
128 opp
= &(GC_gcjobjfreelist
[lw
]);
130 if( (op
= *opp
) == 0 ) {
131 op
= (ptr_t
)GENERAL_MALLOC((word
)lb
, GC_gcj_kind
);
134 return(GC_oom_action());
137 lw
= GC_size_map
[lb
]; /* May have been uninitialized. */
141 GC_words_allocd
+= lw
;
143 *(void **)op
= ptr_to_struct_containing_descr
;
147 op
= (ptr_t
)GENERAL_MALLOC((word
)lb
, GC_gcj_kind
);
150 return(GC_oom_action());
152 *(void **)op
= ptr_to_struct_containing_descr
;
158 /* Similar to GC_gcj_malloc, but add debug info. This is allocated */
159 /* with GC_gcj_debug_kind. */
160 GC_PTR
GC_debug_gcj_malloc(size_t lb
, void * ptr_to_struct_containing_descr
,
165 /* We clone the code from GC_debug_gcj_malloc, so that we */
166 /* dont end up with extra frames on the stack, which could */
167 /* confuse the backtrace. */
169 result
= GC_generic_malloc_inner(lb
+ DEBUG_BYTES
, GC_gcj_debug_kind
);
172 GC_err_printf2("GC_debug_gcj_malloc(%ld, 0x%lx) returning NIL (",
174 (unsigned long) ptr_to_struct_containing_descr
);
176 GC_err_printf1(":%ld)\n", (unsigned long)i
);
177 return(GC_oom_action());
179 *((void **)((ptr_t
)result
+ sizeof(oh
))) = ptr_to_struct_containing_descr
;
181 if (!GC_debugging_started
) {
182 GC_start_debugging();
184 ADD_CALL_CHAIN(result
, ra
);
185 return (GC_store_debug_info(result
, (word
)lb
, s
, (word
)i
));
188 /* Similar to GC_gcj_malloc, but the size is in words, and we don't */
189 /* adjust it. The size is assumed to be such that it can be */
190 /* allocated as a small object. */
191 void * GC_gcj_fast_malloc(size_t lw
, void * ptr_to_struct_containing_descr
)
197 opp
= &(GC_gcjobjfreelist
[lw
]);
199 if( (op
= *opp
) == 0 ) {
200 op
= (ptr_t
)GC_clear_stack(
201 GC_generic_malloc_words_small_inner(lw
, GC_gcj_kind
));
204 return(GC_oom_action());
208 GC_words_allocd
+= lw
;
210 *(void **)op
= ptr_to_struct_containing_descr
;
215 /* And a debugging version of the above: */
216 void * GC_debug_gcj_fast_malloc(size_t lw
,
217 void * ptr_to_struct_containing_descr
,
221 size_t lb
= WORDS_TO_BYTES(lw
);
223 /* We clone the code from GC_debug_gcj_malloc, so that we */
224 /* dont end up with extra frames on the stack, which could */
225 /* confuse the backtrace. */
227 result
= GC_generic_malloc_inner(lb
+ DEBUG_BYTES
, GC_gcj_debug_kind
);
230 GC_err_printf2("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (",
232 (unsigned long) ptr_to_struct_containing_descr
);
234 GC_err_printf1(":%ld)\n", (unsigned long)i
);
235 return(GC_oom_action());
237 *((void **)((ptr_t
)result
+ sizeof(oh
))) = ptr_to_struct_containing_descr
;
239 if (!GC_debugging_started
) {
240 GC_start_debugging();
242 ADD_CALL_CHAIN(result
, ra
);
243 return (GC_store_debug_info(result
, (word
)lb
, s
, (word
)i
));
246 void * GC_gcj_malloc_ignore_off_page(size_t lb
,
247 void * ptr_to_struct_containing_descr
)
250 register ptr_t
* opp
;
254 if( SMALL_OBJ(lb
) ) {
256 lw
= GC_size_map
[lb
];
258 lw
= ALIGNED_WORDS(lb
);
260 opp
= &(GC_gcjobjfreelist
[lw
]);
262 if( (op
= *opp
) == 0 ) {
263 op
= (ptr_t
)GENERAL_MALLOC_IOP(lb
, GC_gcj_kind
);
265 lw
= GC_size_map
[lb
]; /* May have been uninitialized. */
269 GC_words_allocd
+= lw
;
272 *(void **)op
= ptr_to_struct_containing_descr
;
275 op
= (ptr_t
)GENERAL_MALLOC_IOP(lb
, GC_gcj_kind
);
277 *(void **)op
= ptr_to_struct_containing_descr
;
286 char GC_no_gcj_support
;
288 #endif /* GC_GCJ_SUPPORT */