boehm-gc/gcj_mlc.c

   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 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 structure 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 "private/gc_pmark.h"
  40 #include "gc_gcj.h"
  41 #include "private/dbg_mlc.h"
  42
  43 GC_bool GC_gcj_malloc_initialized = FALSE;
  44
  45 int GC_gcj_kind;        /* Object kind for objects with descriptors     */
  46                         /* in "vtable".                                 */
  47 int GC_gcj_debug_kind;  /* The kind of objects that is always marked    */
  48                         /* with a mark proc call.                       */
  49
  50 ptr_t * GC_gcjobjfreelist;
  51 ptr_t * GC_gcjdebugobjfreelist;
  52
  53 /* Caller does not hold allocation lock. */
  54 void GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp)
  55 {
  56     register int i;
  57     GC_bool ignore_gcj_info;
  58     DCL_LOCK_STATE;
  59
  60     GC_init();  /* In case it's not already done.       */
  61     DISABLE_SIGNALS();
  62     LOCK();
  63     if (GC_gcj_malloc_initialized) {
  64       UNLOCK();
  65       ENABLE_SIGNALS();
  66       return;
  67     }
  68     GC_gcj_malloc_initialized = TRUE;
  69     ignore_gcj_info = (0 != GETENV("GC_IGNORE_GCJ_INFO"));
  70 #   ifdef CONDPRINT
  71       if (GC_print_stats && ignore_gcj_info) {
  72         GC_printf0("Gcj-style type information is disabled!\n");
  73       }
  74 #   endif
  75     GC_mark_procs[mp_index] = (GC_mark_proc)mp;
  76     if (mp_index >= GC_n_mark_procs) ABORT("GC_init_gcj_malloc: bad index");
  77     /* Set up object kind gcj-style indirect descriptor. */
  78       GC_gcjobjfreelist = (ptr_t *)
  79           GC_INTERNAL_MALLOC((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
  80       if (GC_gcjobjfreelist == 0) ABORT("Couldn't allocate GC_gcjobjfreelist");
  81       BZERO(GC_gcjobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
  82       GC_gcj_kind = GC_n_kinds++;
  83       GC_obj_kinds[GC_gcj_kind].ok_freelist = GC_gcjobjfreelist;
  84       GC_obj_kinds[GC_gcj_kind].ok_reclaim_list = 0;
  85       if (ignore_gcj_info) {
  86         /* Use a simple length-based descriptor, thus forcing a fully   */
  87         /* conservative scan.                                           */
  88         GC_obj_kinds[GC_gcj_kind].ok_descriptor = (0 | GC_DS_LENGTH);
  89         GC_obj_kinds[GC_gcj_kind].ok_relocate_descr = TRUE;
  90       } else {
  91         GC_obj_kinds[GC_gcj_kind].ok_descriptor =
  92           (((word)(-MARK_DESCR_OFFSET - GC_INDIR_PER_OBJ_BIAS))
  93            | GC_DS_PER_OBJECT);
  94         GC_obj_kinds[GC_gcj_kind].ok_relocate_descr = FALSE;
  95       }
  96       GC_obj_kinds[GC_gcj_kind].ok_init = TRUE;
  97     /* Set up object kind for objects that require mark proc call.      */
  98       GC_gcjdebugobjfreelist = (ptr_t *)
  99           GC_INTERNAL_MALLOC((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
 100       if (GC_gcjdebugobjfreelist == 0)
 101           ABORT("Couldn't allocate GC_gcjdebugobjfreelist");
 102       BZERO(GC_gcjdebugobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
 103       GC_gcj_debug_kind = GC_n_kinds++;
 104       GC_obj_kinds[GC_gcj_debug_kind].ok_freelist = GC_gcjdebugobjfreelist;
 105       GC_obj_kinds[GC_gcj_debug_kind].ok_reclaim_list = 0;
 106       if (ignore_gcj_info) {
 107         GC_obj_kinds[GC_gcj_kind].ok_descriptor = (0 | GC_DS_LENGTH);
 108         GC_obj_kinds[GC_gcj_kind].ok_relocate_descr = TRUE;
 109       } else {
 110         GC_obj_kinds[GC_gcj_debug_kind].ok_descriptor =
 111           GC_MAKE_PROC(mp_index, 1 /* allocated with debug info */);
 112         GC_obj_kinds[GC_gcj_debug_kind].ok_relocate_descr = FALSE;
 113       }
 114       GC_obj_kinds[GC_gcj_debug_kind].ok_init = TRUE;
 115     UNLOCK();
 116     ENABLE_SIGNALS();
 117 }
 118
 119 ptr_t GC_clear_stack();
 120
 121 #define GENERAL_MALLOC(lb,k) \
 122     (GC_PTR)GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
 123
 124 #define GENERAL_MALLOC_IOP(lb,k) \
 125     (GC_PTR)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))
 126
 127 /* Allocate an object, clear it, and store the pointer to the   */
 128 /* type structure (vtable in gcj).                              */
 129 /* This adds a byte at the end of the object if GC_malloc would.*/
 130 void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr)
 131 {
 132 register ptr_t op;
 133 register ptr_t * opp;
 134 register word lw;
 135 DCL_LOCK_STATE;
 136
 137     if( EXPECT(SMALL_OBJ(lb), 1) ) {
 138 #       ifdef MERGE_SIZES
 139           lw = GC_size_map[lb];
 140 #       else
 141           lw = ALIGNED_WORDS(lb);
 142 #       endif
 143         opp = &(GC_gcjobjfreelist[lw]);
 144         LOCK();
 145         op = *opp;
 146         if( EXPECT(op == 0, 0)) {
 147             op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
 148             if (0 == op) {
 149                 UNLOCK();
 150                 return(GC_oom_fn(lb));
 151             }
 152 #           ifdef MERGE_SIZES
 153                 lw = GC_size_map[lb];   /* May have been uninitialized. */
 154 #           endif
 155         } else {
 156             *opp = obj_link(op);
 157             GC_words_allocd += lw;
 158         }
 159         *(void **)op = ptr_to_struct_containing_descr;
 160         GC_ASSERT(((void **)op)[1] == 0);
 161         UNLOCK();
 162     } else {
 163         LOCK();
 164         op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
 165         if (0 == op) {
 166             UNLOCK();
 167             return(GC_oom_fn(lb));
 168         }
 169         *(void **)op = ptr_to_struct_containing_descr;
 170         UNLOCK();
 171     }
 172     return((GC_PTR) op);
 173 }
 174
 175 /* Similar to GC_gcj_malloc, but add debug info.  This is allocated     */
 176 /* with GC_gcj_debug_kind.                                              */
 177 GC_PTR GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
 178                            GC_EXTRA_PARAMS)
 179 {
 180     GC_PTR result;
 181
 182     /* We clone the code from GC_debug_gcj_malloc, so that we   */
 183     /* dont end up with extra frames on the stack, which could  */
 184     /* confuse the backtrace.                                   */
 185     LOCK();
 186     result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
 187     if (result == 0) {
 188         UNLOCK();
 189         GC_err_printf2("GC_debug_gcj_malloc(%ld, 0x%lx) returning NIL (",
 190                        (unsigned long) lb,
 191                        (unsigned long) ptr_to_struct_containing_descr);
 192         GC_err_puts(s);
 193         GC_err_printf1(":%ld)\n", (unsigned long)i);
 194         return(GC_oom_fn(lb));
 195     }
 196     *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
 197     UNLOCK();
 198     if (!GC_debugging_started) {
 199         GC_start_debugging();
 200     }
 201     ADD_CALL_CHAIN(result, ra);
 202     return (GC_store_debug_info(result, (word)lb, s, (word)i));
 203 }
 204
 205 /* Similar to GC_gcj_malloc, but the size is in words, and we don't     */
 206 /* adjust it.  The size is assumed to be such that it can be    */
 207 /* allocated as a small object.                                 */
 208 void * GC_gcj_fast_malloc(size_t lw, void * ptr_to_struct_containing_descr)
 209 {
 210 ptr_t op;
 211 ptr_t * opp;
 212 DCL_LOCK_STATE;
 213
 214     opp = &(GC_gcjobjfreelist[lw]);
 215     LOCK();
 216     op = *opp;
 217     if( EXPECT(op == 0, 0) ) {
 218         op = (ptr_t)GC_clear_stack(
 219                 GC_generic_malloc_words_small_inner(lw, GC_gcj_kind));
 220         if (0 == op) {
 221             UNLOCK();
 222             return GC_oom_fn(WORDS_TO_BYTES(lw));
 223         }
 224     } else {
 225         *opp = obj_link(op);
 226         GC_words_allocd += lw;
 227     }
 228     *(void **)op = ptr_to_struct_containing_descr;
 229     UNLOCK();
 230     return((GC_PTR) op);
 231 }
 232
 233 /* And a debugging version of the above:        */
 234 void * GC_debug_gcj_fast_malloc(size_t lw,
 235                                 void * ptr_to_struct_containing_descr,
 236                                 GC_EXTRA_PARAMS)
 237 {
 238     GC_PTR result;
 239     size_t lb = WORDS_TO_BYTES(lw);
 240
 241     /* We clone the code from GC_debug_gcj_malloc, so that we   */
 242     /* dont end up with extra frames on the stack, which could  */
 243     /* confuse the backtrace.                                   */
 244     LOCK();
 245     result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
 246     if (result == 0) {
 247         UNLOCK();
 248         GC_err_printf2("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (",
 249                        (unsigned long) lw,
 250                        (unsigned long) ptr_to_struct_containing_descr);
 251         GC_err_puts(s);
 252         GC_err_printf1(":%ld)\n", (unsigned long)i);
 253         return GC_oom_fn(WORDS_TO_BYTES(lw));
 254     }
 255     *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
 256     UNLOCK();
 257     if (!GC_debugging_started) {
 258         GC_start_debugging();
 259     }
 260     ADD_CALL_CHAIN(result, ra);
 261     return (GC_store_debug_info(result, (word)lb, s, (word)i));
 262 }
 263
 264 void * GC_gcj_malloc_ignore_off_page(size_t lb,
 265                                      void * ptr_to_struct_containing_descr)
 266 {
 267 register ptr_t op;
 268 register ptr_t * opp;
 269 register word lw;
 270 DCL_LOCK_STATE;
 271
 272     if( SMALL_OBJ(lb) ) {
 273 #       ifdef MERGE_SIZES
 274           lw = GC_size_map[lb];
 275 #       else
 276           lw = ALIGNED_WORDS(lb);
 277 #       endif
 278         opp = &(GC_gcjobjfreelist[lw]);
 279         LOCK();
 280         if( (op = *opp) == 0 ) {
 281             op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
 282 #           ifdef MERGE_SIZES
 283                 lw = GC_size_map[lb];   /* May have been uninitialized. */
 284 #           endif
 285         } else {
 286             *opp = obj_link(op);
 287             GC_words_allocd += lw;
 288         }
 289         *(void **)op = ptr_to_struct_containing_descr;
 290         UNLOCK();
 291     } else {
 292         op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
 293         if (0 != op) {
 294           *(void **)op = ptr_to_struct_containing_descr;
 295         }
 296         UNLOCK();
 297     }
 298     return((GC_PTR) op);
 299 }
 300
 301 #else
 302
 303 char GC_no_gcj_support;
 304
 305 #endif  /* GC_GCJ_SUPPORT */