OSDN Git Service

2005-03-17 Andrew Haley <aph@redhat.com>
[pf3gnuchains/gcc-fork.git] / libjava / boehm.cc
1 // boehm.cc - interface between libjava and Boehm GC.
2
3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004
4    Free Software Foundation
5
6    This file is part of libgcj.
7
8 This software is copyrighted work licensed under the terms of the
9 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
10 details.  */
11
12 #include <config.h>
13
14 #include <stdio.h>
15 #include <limits.h>
16
17 #include <jvm.h>
18 #include <gcj/cni.h>
19
20 #include <java/lang/Class.h>
21 #include <java/lang/reflect/Modifier.h>
22 #include <java-interp.h>
23
24 // More nastiness: the GC wants to define TRUE and FALSE.  We don't
25 // need the Java definitions (themselves a hack), so we undefine them.
26 #undef TRUE
27 #undef FALSE
28
29 extern "C"
30 {
31 #include <gc_config.h>
32
33 // Set GC_DEBUG before including gc.h!
34 #ifdef LIBGCJ_GC_DEBUG
35 # define GC_DEBUG
36 #endif
37
38 #include <gc_mark.h>
39 #include <gc_gcj.h>
40 #include <javaxfc.h>  // GC_finalize_all declaration.  
41
42 #ifdef THREAD_LOCAL_ALLOC
43 # define GC_REDIRECT_TO_LOCAL
44 # include <gc_local_alloc.h>
45 #endif
46
47   // From boehm's misc.c 
48   void GC_enable();
49   void GC_disable();
50 };
51
52 #define MAYBE_MARK(Obj, Top, Limit, Source)  \
53         Top=GC_MARK_AND_PUSH((GC_PTR) Obj, Top, Limit, (GC_PTR *) Source)
54
55 // `kind' index used when allocating Java arrays.
56 static int array_kind_x;
57
58 // Freelist used for Java arrays.
59 static void **array_free_list;
60
61 \f
62
63 // This is called by the GC during the mark phase.  It marks a Java
64 // object.  We use `void *' arguments and return, and not what the
65 // Boehm GC wants, to avoid pollution in our headers.
66 void *
67 _Jv_MarkObj (void *addr, void *msp, void *msl, void *env)
68 {
69   struct GC_ms_entry *mark_stack_ptr = (struct GC_ms_entry *)msp;
70   struct GC_ms_entry *mark_stack_limit = (struct GC_ms_entry *)msl;
71
72   if (env == (void *)1) /* Object allocated with debug allocator.       */
73     addr = (GC_PTR)GC_USR_PTR_FROM_BASE(addr);
74   jobject obj = (jobject) addr;
75
76   _Jv_VTable *dt = *(_Jv_VTable **) addr;
77   // The object might not yet have its vtable set, or it might
78   // really be an object on the freelist.  In either case, the vtable slot
79   // will either be 0, or it will point to a cleared object.
80   // This assumes Java objects have size at least 3 words,
81   // including the header.   But this should remain true, since this
82   // should only be used with debugging allocation or with large objects.
83   if (__builtin_expect (! dt || !(dt -> get_finalizer()), false))
84     return mark_stack_ptr;
85   jclass klass = dt->clas;
86   GC_PTR p;
87
88 # ifndef JV_HASH_SYNCHRONIZATION
89     // Every object has a sync_info pointer.
90     p = (GC_PTR) obj->sync_info;
91     MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
92 # endif
93   // Mark the object's class.
94   p = (GC_PTR) klass;
95   MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
96
97   if (__builtin_expect (klass == &java::lang::Class::class$, false))
98     {
99       // Currently we allocate some of the memory referenced from class objects
100       // as pointerfree memory, and then mark it more intelligently here.
101       // We ensure that the ClassClass mark descriptor forces invocation of
102       // this procedure.
103       // Correctness of this is subtle, but it looks OK to me for now.  For the incremental
104       // collector, we need to make sure that the class object is written whenever
105       // any of the subobjects are altered and may need rescanning.  This may be tricky
106       // during construction, and this may not be the right way to do this with
107       // incremental collection.
108       // If we overflow the mark stack, we will rescan the class object, so we should
109       // be OK.  The same applies if we redo the mark phase because win32 unmapped part
110       // of our root set.               - HB
111       jclass c = (jclass) addr;
112
113       p = (GC_PTR) c->name;
114       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
115       p = (GC_PTR) c->superclass;
116       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
117       for (int i = 0; i < c->constants.size; ++i)
118         {
119           /* FIXME: We could make this more precise by using the tags -KKT */
120           p = (GC_PTR) c->constants.data[i].p;
121           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
122         }
123
124 #ifdef INTERPRETER
125       if (_Jv_IsInterpretedClass (c))
126         {
127           p = (GC_PTR) c->constants.tags;
128           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
129           p = (GC_PTR) c->constants.data;
130           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
131         }
132 #endif
133
134       // The vtable might be allocated even for compiled code.
135       p = (GC_PTR) c->vtable;
136       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
137
138       // If the class is an array, then the methods field holds a
139       // pointer to the element class.  If the class is primitive,
140       // then the methods field holds a pointer to the array class.
141       p = (GC_PTR) c->methods;
142       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
143
144       // The vtable might have been set, but the rest of the class
145       // could still be uninitialized.  If this is the case, then
146       // c.isArray will SEGV.  We check for this, and if it is the
147       // case we just return.
148       if (__builtin_expect (c->name == NULL, false))
149         return mark_stack_ptr;
150
151       if (! c->isArray() && ! c->isPrimitive())
152         {
153           // Scan each method in the cases where `methods' really
154           // points to a methods structure.
155           for (int i = 0; i < c->method_count; ++i)
156             {
157               p = (GC_PTR) c->methods[i].name;
158               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
159               p = (GC_PTR) c->methods[i].signature;
160               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
161
162               // Note that we don't have to mark each individual throw
163               // separately, as these are stored in the constant pool.
164               p = (GC_PTR) c->methods[i].throws;
165               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
166             }
167         }
168
169       // Mark all the fields.
170       p = (GC_PTR) c->fields;
171       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
172       for (int i = 0; i < c->field_count; ++i)
173         {
174           _Jv_Field* field = &c->fields[i];
175
176           p = (GC_PTR) field->name;
177           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
178           p = (GC_PTR) field->type;
179           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
180
181           // For the interpreter, we also need to mark the memory
182           // containing static members
183           if ((field->flags & java::lang::reflect::Modifier::STATIC))
184             {
185               p = (GC_PTR) field->u.addr;
186               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
187
188               // also, if the static member is a reference,
189               // mark also the value pointed to.  We check for isResolved
190               // since marking can happen before memory is allocated for
191               // static members.
192               if (JvFieldIsRef (field) && field->isResolved()) 
193                 {
194                   jobject val = *(jobject*) field->u.addr;
195                   p = (GC_PTR) val;
196                   MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
197                 }
198             }
199         }
200
201       p = (GC_PTR) c->vtable;
202       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
203       p = (GC_PTR) c->interfaces;
204       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
205       for (int i = 0; i < c->interface_count; ++i)
206         {
207           p = (GC_PTR) c->interfaces[i];
208           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
209         }
210       p = (GC_PTR) c->loader;
211       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
212
213       // The dispatch tables can be allocated at runtime.
214       p = (GC_PTR) c->ancestors;
215       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
216       if (c->idt)
217         {
218           p = (GC_PTR) c->idt;
219           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
220
221           if (c->isInterface())
222             {
223               p = (GC_PTR) c->idt->iface.ioffsets;
224               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c->idt);
225             }
226           else if (! c->isPrimitive())
227             {
228               // This field is only valid for ordinary classes.
229               p = (GC_PTR) c->idt->cls.itable;
230               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c->idt);
231             }
232         }
233
234       p = (GC_PTR) c->arrayclass;
235       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
236       p = (GC_PTR) c->protectionDomain;
237       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
238       p = (GC_PTR) c->hack_signers;
239       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
240       p = (GC_PTR) c->aux_info;
241       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
242
243 #ifdef INTERPRETER
244       if (_Jv_IsInterpretedClass (c) && c->aux_info)
245         {
246           _Jv_InterpClass* ic = (_Jv_InterpClass*) c->aux_info;
247
248           p = (GC_PTR) ic->interpreted_methods;
249           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
250
251           p = (GC_PTR) ic->source_file_name;
252           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
253
254           for (int i = 0; i < c->method_count; i++)
255             {
256               // The interpreter installs a heap-allocated trampoline
257               // here, so we'll mark it.
258               p = (GC_PTR) c->methods[i].ncode;
259               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
260
261               using namespace java::lang::reflect;
262
263               // Mark the direct-threaded code.  Note a subtlety here:
264               // when we add Miranda methods to a class, we don't
265               // resize its interpreted_methods array.  If we try to
266               // reference one of these methods, we may crash.
267               // However, we know these are all abstract, and we know
268               // that abstract methods have nothing useful in this
269               // array.  So, we skip all abstract methods to avoid the
270               // problem.  FIXME: this is pretty obscure, it may be
271               // better to add a methods to the execution engine and
272               // resize the array.
273               if ((c->methods[i].accflags & Modifier::ABSTRACT) != 0)
274                 continue;
275
276               p = (GC_PTR) ic->interpreted_methods[i];
277               MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
278
279               if ((c->methods[i].accflags & Modifier::NATIVE) != 0)
280                 {
281                   _Jv_JNIMethod *jm
282                     = (_Jv_JNIMethod *) ic->interpreted_methods[i];
283                   if (jm)
284                     {
285                       p = (GC_PTR) jm->jni_arg_types;
286                       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, p);
287                     }
288                 }
289               else
290                 {
291                   _Jv_InterpMethod *im
292                     = (_Jv_InterpMethod *) ic->interpreted_methods[i];
293                   if (im)
294                     {
295                       p = (GC_PTR) im->line_table;
296                       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
297                       p = (GC_PTR) im->prepared;
298                       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
299                     }
300                 }
301             }
302
303           p = (GC_PTR) ic->field_initializers;
304           MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
305           
306         }
307 #endif
308
309     }
310   else
311     {
312       // NOTE: each class only holds information about the class
313       // itself.  So we must do the marking for the entire inheritance
314       // tree in order to mark all fields.  FIXME: what about
315       // interfaces?  We skip Object here, because Object only has a
316       // sync_info, and we handled that earlier.
317       // Note: occasionally `klass' can be null.  For instance, this
318       // can happen if a GC occurs between the point where an object
319       // is allocated and where the vtbl slot is set.
320       while (klass && klass != &java::lang::Object::class$)
321         {
322           jfieldID field = JvGetFirstInstanceField (klass);
323           jint max = JvNumInstanceFields (klass);
324
325           for (int i = 0; i < max; ++i)
326             {
327               if (JvFieldIsRef (field))
328                 {
329                   jobject val = JvGetObjectField (obj, field);
330                   p = (GC_PTR) val;
331                   MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
332                 }
333               field = field->getNextField ();
334             }
335           klass = klass->getSuperclass();
336         }
337     }
338
339   return mark_stack_ptr;
340 }
341
342 // This is called by the GC during the mark phase.  It marks a Java
343 // array (of objects).  We use `void *' arguments and return, and not
344 // what the Boehm GC wants, to avoid pollution in our headers.
345 void *
346 _Jv_MarkArray (void *addr, void *msp, void *msl, void *env)
347 {
348   struct GC_ms_entry *mark_stack_ptr = (struct GC_ms_entry *)msp;
349   struct GC_ms_entry *mark_stack_limit = (struct GC_ms_entry *)msl;
350
351   if (env == (void *)1) /* Object allocated with debug allocator.       */
352     addr = (void *)GC_USR_PTR_FROM_BASE(addr);
353   jobjectArray array = (jobjectArray) addr;
354
355   _Jv_VTable *dt = *(_Jv_VTable **) addr;
356   // Assumes size >= 3 words.  That's currently true since arrays have
357   // a vtable, sync pointer, and size.  If the sync pointer goes away,
358   // we may need to round up the size.
359   if (__builtin_expect (! dt || !(dt -> get_finalizer()), false))
360     return mark_stack_ptr;
361   jclass klass = dt->clas;
362   GC_PTR p;
363
364 # ifndef JV_HASH_SYNCHRONIZATION
365     // Every object has a sync_info pointer.
366     p = (GC_PTR) array->sync_info;
367     MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array);
368 # endif
369   // Mark the object's class.
370   p = (GC_PTR) klass;
371   MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, &(dt -> clas));
372
373   for (int i = 0; i < JvGetArrayLength (array); ++i)
374     {
375       jobject obj = elements (array)[i];
376       p = (GC_PTR) obj;
377       MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array);
378     }
379
380   return mark_stack_ptr;
381 }
382
383 // Generate a GC marking descriptor for a class.
384 //
385 // We assume that the gcj mark proc has index 0.  This is a dubious assumption,
386 // since another one could be registered first.  But the compiler also
387 // knows this, so in that case everything else will break, too.
388 #define GCJ_DEFAULT_DESCR GC_MAKE_PROC(GC_GCJ_RESERVED_MARK_PROC_INDEX,0)
389
390 void *
391 _Jv_BuildGCDescr(jclass self)
392 {
393   jlong desc = 0;
394   jint bits_per_word = CHAR_BIT * sizeof (void *);
395
396   // Note: for now we only consider a bitmap mark descriptor.  We
397   // could also handle the case where the first N fields of a type are
398   // references.  However, this is not very likely to be used by many
399   // classes, and it is easier to compute things this way.
400
401   // The vtable pointer.
402   desc |= 1ULL << (bits_per_word - 1);
403 #ifndef JV_HASH_SYNCHRONIZATION
404   // The sync_info field.
405   desc |= 1ULL << (bits_per_word - 2);
406 #endif
407
408   for (jclass klass = self; klass != NULL; klass = klass->getSuperclass())
409     {
410       jfieldID field = JvGetFirstInstanceField(klass);
411       int count = JvNumInstanceFields(klass);
412
413       for (int i = 0; i < count; ++i)
414         {
415           if (field->isRef())
416             {
417               unsigned int off = field->getOffset();
418               // If we run into a weird situation, we bail.
419               if (off % sizeof (void *) != 0)
420                 return (void *) (GCJ_DEFAULT_DESCR);
421               off /= sizeof (void *);
422               // If we find a field outside the range of our bitmap,
423               // fall back to procedure marker. The bottom 2 bits are
424               // reserved.
425               if (off >= (unsigned) bits_per_word - 2)
426                 return (void *) (GCJ_DEFAULT_DESCR);
427               desc |= 1ULL << (bits_per_word - off - 1);
428             }
429
430           field = field->getNextField();
431         }
432     }
433
434   // For bitmap mark type, bottom bits are 01.
435   desc |= 1;
436   // Bogus warning avoidance (on many platforms).
437   return (void *) (unsigned long) desc;
438 }
439
440 // Allocate some space that is known to be pointer-free.
441 void *
442 _Jv_AllocBytes (jsize size)
443 {
444   void *r = GC_MALLOC_ATOMIC (size);
445   // We have to explicitly zero memory here, as the GC doesn't
446   // guarantee that PTRFREE allocations are zeroed.  Note that we
447   // don't have to do this for other allocation types because we set
448   // the `ok_init' flag in the type descriptor.
449   memset (r, 0, size);
450   return r;
451 }
452
453 #ifdef LIBGCJ_GC_DEBUG
454
455 void *
456 _Jv_AllocObj (jsize size, jclass klass)
457 {
458   return GC_GCJ_MALLOC (size, klass->vtable);
459 }
460
461 void *
462 _Jv_AllocPtrFreeObj (jsize size, jclass klass)
463 {
464 #ifdef JV_HASH_SYNCHRONIZATION
465   void * obj = GC_MALLOC_ATOMIC(size);
466   *((_Jv_VTable **) obj) = klass->vtable;
467 #else
468   void * obj = GC_GCJ_MALLOC(size, klass->vtable);
469 #endif
470   return obj;
471 }
472
473 #endif /* LIBGCJ_GC_DEBUG */
474 // In the non-debug case, the above two functions are defined
475 // as inline functions in boehm-gc.h.  In the debug case we
476 // really want to take advantage of the definitions in gc_gcj.h.
477
478 // Allocate space for a new Java array.
479 // Used only for arrays of objects.
480 void *
481 _Jv_AllocArray (jsize size, jclass klass)
482 {
483   void *obj;
484
485 #ifdef LIBGCJ_GC_DEBUG
486   // There isn't much to lose by scanning this conservatively.
487   // If we didn't, the mark proc would have to understand that
488   // it needed to skip the header.
489   obj = GC_MALLOC(size);
490 #else
491   const jsize min_heap_addr = 16*1024;
492   // A heuristic.  If size is less than this value, the size
493   // stored in the array can't possibly be misinterpreted as
494   // a pointer.   Thus we lose nothing by scanning the object
495   // completely conservatively, since no misidentification can
496   // take place.
497   
498   if (size < min_heap_addr) 
499     obj = GC_MALLOC(size);
500   else 
501     obj = GC_generic_malloc (size, array_kind_x);
502 #endif
503   *((_Jv_VTable **) obj) = klass->vtable;
504   return obj;
505 }
506
507 /* Allocate space for a new non-Java object, which does not have the usual 
508    Java object header but may contain pointers to other GC'ed objects. */
509 void *
510 _Jv_AllocRawObj (jsize size)
511 {
512   return (void *) GC_MALLOC (size);
513 }
514
515 static void
516 call_finalizer (GC_PTR obj, GC_PTR client_data)
517 {
518   _Jv_FinalizerFunc *fn = (_Jv_FinalizerFunc *) client_data;
519   jobject jobj = (jobject) obj;
520
521   (*fn) (jobj);
522 }
523
524 void
525 _Jv_RegisterFinalizer (void *object, _Jv_FinalizerFunc *meth)
526 {
527   GC_REGISTER_FINALIZER_NO_ORDER (object, call_finalizer, (GC_PTR) meth,
528                                   NULL, NULL);
529 }
530
531 void
532 _Jv_RunFinalizers (void)
533 {
534   GC_invoke_finalizers ();
535 }
536
537 void
538 _Jv_RunAllFinalizers (void)
539 {
540   GC_finalize_all ();
541 }
542
543 void
544 _Jv_RunGC (void)
545 {
546   GC_gcollect ();
547 }
548
549 long
550 _Jv_GCTotalMemory (void)
551 {
552   return GC_get_heap_size ();
553 }
554
555 long
556 _Jv_GCFreeMemory (void)
557 {
558   return GC_get_free_bytes ();
559 }
560
561 void
562 _Jv_GCSetInitialHeapSize (size_t size)
563 {
564   size_t current = GC_get_heap_size ();
565   if (size > current)
566     GC_expand_hp (size - current);
567 }
568
569 void
570 _Jv_GCSetMaximumHeapSize (size_t size)
571 {
572   GC_set_max_heap_size ((GC_word) size);
573 }
574
575 void
576 _Jv_DisableGC (void)
577 {
578   GC_disable();
579 }
580
581 void
582 _Jv_EnableGC (void)
583 {
584   GC_enable();
585 }
586
587 static void * handle_out_of_memory(size_t)
588 {
589   _Jv_ThrowNoMemory();
590 }
591
592 static void
593 gcj_describe_type_fn(void *obj, char *out_buf)
594 {
595   _Jv_VTable *dt = *(_Jv_VTable **) obj;
596
597   if (! dt /* Shouldn't happen */)
598     {
599       strcpy(out_buf, "GCJ (bad)");
600       return;
601     }
602   jclass klass = dt->clas;
603   if (!klass /* shouldn't happen */)
604     {
605       strcpy(out_buf, "GCJ (bad)");
606       return;
607     }
608   jstring name = klass -> getName();
609   size_t len = name -> length();
610   if (len >= GC_TYPE_DESCR_LEN) len = GC_TYPE_DESCR_LEN - 1;
611   JvGetStringUTFRegion (name, 0, len, out_buf);
612   out_buf[len] = '\0';
613 }
614
615 void
616 _Jv_InitGC (void)
617 {
618   int proc;
619
620   // Ignore pointers that do not point to the start of an object.
621   GC_all_interior_pointers = 0;
622
623   // Configure the collector to use the bitmap marking descriptors that we
624   // stash in the class vtable.
625   // We always use mark proc descriptor 0, since the compiler knows
626   // about it.
627   GC_init_gcj_malloc (0, (void *) _Jv_MarkObj);  
628
629   // Cause an out of memory error to be thrown from the allocators,
630   // instead of returning 0.  This is cheaper than checking on allocation.
631   GC_oom_fn = handle_out_of_memory;
632
633   GC_java_finalization = 1;
634
635   // We use a different mark procedure for object arrays. This code 
636   // configures a different object `kind' for object array allocation and
637   // marking.
638   array_free_list = GC_new_free_list();
639   proc = GC_new_proc((GC_mark_proc)_Jv_MarkArray);
640   array_kind_x = GC_new_kind(array_free_list, GC_MAKE_PROC (proc, 0), 0, 1);
641
642   // Arrange to have the GC print Java class names in backtraces, etc.
643   GC_register_describe_type_fn(GC_gcj_kind, gcj_describe_type_fn);
644   GC_register_describe_type_fn(GC_gcj_debug_kind, gcj_describe_type_fn);
645 }
646
647 #ifdef JV_HASH_SYNCHRONIZATION
648 // Allocate an object with a fake vtable pointer, which causes only
649 // the first field (beyond the fake vtable pointer) to be traced.
650 // Eventually this should probably be generalized.
651
652 static _Jv_VTable trace_one_vtable = {
653     0,                  // class pointer
654     (void *)(2 * sizeof(void *)),
655                         // descriptor; scan 2 words incl. vtable ptr.
656                         // Least significant bits must be zero to
657                         // identify this as a length descriptor
658     {0}                 // First method
659 };
660
661 void *
662 _Jv_AllocTraceOne (jsize size /* includes vtable slot */) 
663 {
664   return GC_GCJ_MALLOC (size, &trace_one_vtable);
665 }
666
667 // Ditto for two words.
668 // the first field (beyond the fake vtable pointer) to be traced.
669 // Eventually this should probably be generalized.
670
671 static _Jv_VTable trace_two_vtable =
672 {
673   0,                    // class pointer
674   (void *)(3 * sizeof(void *)),
675                         // descriptor; scan 3 words incl. vtable ptr.
676   {0}                   // First method
677 };
678
679 void *
680 _Jv_AllocTraceTwo (jsize size /* includes vtable slot */) 
681 {
682   return GC_GCJ_MALLOC (size, &trace_two_vtable);
683 }
684
685 #endif /* JV_HASH_SYNCHRONIZATION */
686
687 void
688 _Jv_GCInitializeFinalizers (void (*notifier) (void))
689 {
690   GC_finalize_on_demand = 1;
691   GC_finalizer_notifier = notifier;
692 }
693
694 void
695 _Jv_GCRegisterDisappearingLink (jobject *objp)
696 {
697   // This test helps to ensure that we meet a precondition of
698   // GC_general_register_disappearing_link, viz. "Obj must be a
699   // pointer to the first word of an object we allocated."
700   if (GC_base(*objp))
701     GC_general_register_disappearing_link ((GC_PTR *) objp, (GC_PTR) *objp);
702 }
703
704 jboolean
705 _Jv_GCCanReclaimSoftReference (jobject)
706 {
707   // For now, always reclaim soft references.  FIXME.
708   return true;
709 }