[gcc.git] / boehm-gc / gcj_mlc.c

/*
 * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
 * Copyright (c) 1999 by Hewlett-Packard Company.  All rights reserved.
 *
 * 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.
 *
 */
/* Boehm, July 31, 1995 5:02 pm PDT */

#ifdef GC_GCJ_SUPPORT

/*
 * This is an allocator interface tuned for gcj (the GNU/Cygnus 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 structur 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) We have an ANSI conforming C compiler.
 *  2) Counting on explicit initialization of this interface is OK.
 *  3) FASTLOCK is not a significant win.
 */

#include "gc_priv.h"
#include "gc_mark.h"
#include "include/gc_gcj.h"
#include "dbg_mlc.h"

GC_bool GC_gcj_malloc_initialized = FALSE;

int GC_gcj_kind;	/* Object kind for objects with descriptors     */
			/* in "vtable".					*/
int GC_gcj_debug_kind;	/* The kind of objects that is always marked 	*/
			/* with a mark proc call.			*/

ptr_t * GC_gcjobjfreelist;
ptr_t * GC_gcjdebugobjfreelist;

void * GC_default_oom_action(void) { return 0; }

void * (*GC_oom_action)(void) = GC_default_oom_action;

/* Caller does not hold allocation lock. */
void GC_init_gcj_malloc(int mp_index, void * /* really mark_proc */mp)
{
    register int i;
    DCL_LOCK_STATE;

    GC_init();	/* In case it's not already done.	*/
    DISABLE_SIGNALS();
    LOCK();
    if (GC_gcj_malloc_initialized) {
      UNLOCK();
      ENABLE_SIGNALS();
      return;
    }
    GC_gcj_malloc_initialized = TRUE;
    GC_mark_procs[mp_index] = (mark_proc)mp;
    if (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_generic_malloc_inner((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
      if (GC_gcjobjfreelist == 0) ABORT("Couldn't allocate GC_gcjobjfreelist");
      BZERO(GC_gcjobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
      GC_gcj_kind = GC_n_kinds++;
      GC_obj_kinds[GC_gcj_kind].ok_freelist = GC_gcjobjfreelist;
      GC_obj_kinds[GC_gcj_kind].ok_reclaim_list = 0;
      GC_obj_kinds[GC_gcj_kind].ok_descriptor =
    	(((word)(-MARK_DESCR_OFFSET - INDIR_PER_OBJ_BIAS)) | DS_PER_OBJECT);
      GC_obj_kinds[GC_gcj_kind].ok_relocate_descr = FALSE;
      GC_obj_kinds[GC_gcj_kind].ok_init = TRUE;
    /* Set up object kind for objects that require mark proc call.	*/
      GC_gcjdebugobjfreelist = (ptr_t *)
          GC_generic_malloc_inner((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
      if (GC_gcjdebugobjfreelist == 0)
	  ABORT("Couldn't allocate GC_gcjdebugobjfreelist");
      BZERO(GC_gcjdebugobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
      GC_gcj_debug_kind = GC_n_kinds++;
      GC_obj_kinds[GC_gcj_debug_kind].ok_freelist = GC_gcjdebugobjfreelist;
      GC_obj_kinds[GC_gcj_debug_kind].ok_reclaim_list = 0;
      GC_obj_kinds[GC_gcj_debug_kind].ok_descriptor =
    	MAKE_PROC(mp_index, 1 /* allocated with debug info */);
      GC_obj_kinds[GC_gcj_debug_kind].ok_relocate_descr = FALSE;
      GC_obj_kinds[GC_gcj_debug_kind].ok_init = TRUE;
    UNLOCK();
    ENABLE_SIGNALS();
}

ptr_t GC_clear_stack();

#define GENERAL_MALLOC(lb,k) \
    (GC_PTR)GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
    
#define GENERAL_MALLOC_IOP(lb,k) \
    (GC_PTR)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))

/* 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.*/
void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr)
{
register ptr_t op;
register ptr_t * opp;
register word lw;
DCL_LOCK_STATE;

    if( SMALL_OBJ(lb) ) {
#       ifdef MERGE_SIZES
	  lw = GC_size_map[lb];
#	else
	  lw = ALIGNED_WORDS(lb);
#       endif
	opp = &(GC_gcjobjfreelist[lw]);
	LOCK();
        if( (op = *opp) == 0 ) {
            op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
	    if (0 == op) {
		UNLOCK();
		return(GC_oom_action());
	    }
#	    ifdef MERGE_SIZES
		lw = GC_size_map[lb];	/* May have been uninitialized.	*/
#	    endif
        } else {
            *opp = obj_link(op);
            GC_words_allocd += lw;
            FASTUNLOCK();
        }
	*(void **)op = ptr_to_struct_containing_descr;
	UNLOCK();
    } else {
	LOCK();
	op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
	if (0 == op) {
	    UNLOCK();
	    return(GC_oom_action());
	}
	*(void **)op = ptr_to_struct_containing_descr;
	UNLOCK();
    }
    return((GC_PTR) op);
}

/* Similar to GC_gcj_malloc, but add debug info.  This is allocated	*/
/* with GC_gcj_debug_kind.						*/
GC_PTR GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
			   GC_EXTRA_PARAMS)
{
    GC_PTR result;

    /* We clone the code from GC_debug_gcj_malloc, so that we 	*/
    /* dont end up with extra frames on the stack, which could	*/
    /* confuse the backtrace.					*/
    LOCK();
    result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
    if (result == 0) {
	UNLOCK();
        GC_err_printf2("GC_debug_gcj_malloc(%ld, 0x%lx) returning NIL (",
        	       (unsigned long) lb,
		       (unsigned long) ptr_to_struct_containing_descr);
        GC_err_puts(s);
        GC_err_printf1(":%ld)\n", (unsigned long)i);
        return(GC_oom_action());
    }
    *((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, (word)i));
}

/* Similar to GC_gcj_malloc, but the size is in words, and we don't	*/
/* adjust it.  The size is assumed to be such that it can be 	*/
/* allocated as a small object.					*/
void * GC_gcj_fast_malloc(size_t lw, void * ptr_to_struct_containing_descr)
{
ptr_t op;
ptr_t * opp;
DCL_LOCK_STATE;

    opp = &(GC_gcjobjfreelist[lw]);
    LOCK();
    if( (op = *opp) == 0 ) {
        op = (ptr_t)GC_clear_stack(
		GC_generic_malloc_words_small_inner(lw, GC_gcj_kind));
	if (0 == op) {
	    UNLOCK();
	    return(GC_oom_action());
	}
    } else {
        *opp = obj_link(op);
        GC_words_allocd += lw;
    }
    *(void **)op = ptr_to_struct_containing_descr;
    UNLOCK();
    return((GC_PTR) op);
}

/* And a debugging version of the above:	*/
void * GC_debug_gcj_fast_malloc(size_t lw,
				void * ptr_to_struct_containing_descr,
				GC_EXTRA_PARAMS)
{
    GC_PTR result;
    size_t lb = WORDS_TO_BYTES(lw);

    /* We clone the code from GC_debug_gcj_malloc, so that we 	*/
    /* dont end up with extra frames on the stack, which could	*/
    /* confuse the backtrace.					*/
    LOCK();
    result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
    if (result == 0) {
	UNLOCK();
        GC_err_printf2("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (",
        	       (unsigned long) lw,
		       (unsigned long) ptr_to_struct_containing_descr);
        GC_err_puts(s);
        GC_err_printf1(":%ld)\n", (unsigned long)i);
        return(GC_oom_action());
    }
    *((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, (word)i));
}

void * GC_gcj_malloc_ignore_off_page(size_t lb,
				     void * ptr_to_struct_containing_descr) 
{
register ptr_t op;
register ptr_t * opp;
register word lw;
DCL_LOCK_STATE;

    if( SMALL_OBJ(lb) ) {
#       ifdef MERGE_SIZES
	  lw = GC_size_map[lb];
#	else
	  lw = ALIGNED_WORDS(lb);
#       endif
	opp = &(GC_gcjobjfreelist[lw]);
	LOCK();
        if( (op = *opp) == 0 ) {
            op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
#	    ifdef MERGE_SIZES
		lw = GC_size_map[lb];	/* May have been uninitialized.	*/
#	    endif
        } else {
            *opp = obj_link(op);
            GC_words_allocd += lw;
            FASTUNLOCK();
        }
	*(void **)op = ptr_to_struct_containing_descr;
	UNLOCK();
    } else {
        op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
        if (0 != op) {
          *(void **)op = ptr_to_struct_containing_descr;
	}
        UNLOCK();
    }
    return((GC_PTR) op);
}

#else

char GC_no_gcj_support;

#endif  /* GC_GCJ_SUPPORT */
Commit	Line	Data
0eebf9e5 BM	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
179977c1 BM	285	#else
	286
	287	char GC_no_gcj_support;
	288
0eebf9e5	289	#endif /* GC_GCJ_SUPPORT */