2 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
3 * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
4 * Copyright (c) 1999-2001 by Hewlett-Packard Company. All rights reserved.
6 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
7 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
9 * Permission is hereby granted to use or copy this program
10 * for any purpose, provided the above notices are retained on all copies.
11 * Permission to modify the code and to distribute modified code is granted,
12 * provided the above notices are retained, and a notice that the code was
13 * modified is included with the above copyright notice.
15 /* Boehm, July 31, 1995 5:02 pm PDT */
24 #define I_HIDE_POINTERS /* To make GC_call_with_alloc_lock visible */
25 #include "private/gc_pmark.h"
27 #ifdef GC_SOLARIS_THREADS
28 # include <sys/syscall.h>
30 #if defined(MSWIN32) || defined(MSWINCE)
31 # define WIN32_LEAN_AND_MEAN
39 # include "il/PCR_IL.h"
40 PCR_Th_ML GC_allocate_ml
;
43 /* Critical section counter is defined in the M3 runtime */
44 /* That's all we use. */
46 # ifdef GC_SOLARIS_THREADS
47 mutex_t GC_allocate_ml
; /* Implicitly initialized. */
49 # if defined(GC_WIN32_THREADS)
50 # if defined(GC_PTHREADS)
51 pthread_mutex_t GC_allocate_ml
= PTHREAD_MUTEX_INITIALIZER
;
52 # elif defined(GC_DLL)
53 __declspec(dllexport
) CRITICAL_SECTION GC_allocate_ml
;
55 CRITICAL_SECTION GC_allocate_ml
;
58 # if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS)
59 # if defined(USE_SPIN_LOCK)
60 pthread_t GC_lock_holder
= NO_THREAD
;
62 pthread_mutex_t GC_allocate_ml
= PTHREAD_MUTEX_INITIALIZER
;
63 pthread_t GC_lock_holder
= NO_THREAD
;
64 /* Used only for assertions, and to prevent */
65 /* recursive reentry in the system call wrapper. */
68 --> declare allocator lock here
76 #if defined(NOSYS) || defined(ECOS)
80 /* Dont unnecessarily call GC_register_main_static_data() in case */
81 /* dyn_load.c isn't linked in. */
82 #ifdef DYNAMIC_LOADING
83 # define GC_REGISTER_MAIN_STATIC_DATA() GC_register_main_static_data()
84 #elif defined(GC_DONT_REGISTER_MAIN_STATIC_DATA)
85 # define GC_REGISTER_MAIN_STATIC_DATA() FALSE
87 # define GC_REGISTER_MAIN_STATIC_DATA() TRUE
90 GC_FAR
struct _GC_arrays GC_arrays
/* = { 0 } */;
93 GC_bool GC_debugging_started
= FALSE
;
94 /* defined here so we don't have to load debug_malloc.o */
96 void (*GC_check_heap
) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0;
97 void (*GC_print_all_smashed
) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0;
99 void (*GC_start_call_back
) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0;
101 ptr_t GC_stackbottom
= 0;
104 ptr_t GC_register_stackbottom
= 0;
107 GC_bool GC_dont_gc
= 0;
109 GC_bool GC_dont_precollect
= 0;
111 GC_bool GC_quiet
= 0;
113 GC_bool GC_print_stats
= 0;
115 GC_bool GC_print_back_height
= 0;
118 GC_bool GC_dump_regularly
= 0; /* Generate regular debugging dumps. */
121 #ifdef KEEP_BACK_PTRS
122 long GC_backtraces
= 0; /* Number of random backtraces to */
123 /* generate for each GC. */
127 int GC_find_leak
= 1;
129 int GC_find_leak
= 0;
132 #ifdef ALL_INTERIOR_POINTERS
133 int GC_all_interior_pointers
= 1;
135 int GC_all_interior_pointers
= 0;
138 long GC_large_alloc_warn_interval
= 5;
139 /* Interval between unsuppressed warnings. */
141 long GC_large_alloc_warn_suppressed
= 0;
142 /* Number of warnings suppressed so far. */
145 GC_PTR GC_default_oom_fn
GC_PROTO((size_t bytes_requested
))
150 GC_PTR (*GC_oom_fn
) GC_PROTO((size_t bytes_requested
)) = GC_default_oom_fn
;
152 extern signed_word GC_mem_found
;
154 void * GC_project2(arg1
, arg2
)
162 /* Set things up so that GC_size_map[i] >= words(i), */
163 /* but not too much bigger */
164 /* and so that size_map contains relatively few distinct entries */
165 /* This is stolen from Russ Atkinson's Cedar quantization */
166 /* alogrithm (but we precompute it). */
169 void GC_init_size_map()
173 /* Map size 0 to something bigger. */
174 /* This avoids problems at lower levels. */
175 /* One word objects don't have to be 2 word aligned, */
176 /* unless we're using mark bytes. */
177 for (i
= 0; i
< sizeof(word
); i
++) {
178 GC_size_map
[i
] = MIN_WORDS
;
181 GC_size_map
[sizeof(word
)] = MIN_WORDS
;
183 GC_size_map
[sizeof(word
)] = ROUNDED_UP_WORDS(sizeof(word
));
185 for (i
= sizeof(word
) + 1; i
<= 8 * sizeof(word
); i
++) {
186 GC_size_map
[i
] = ALIGNED_WORDS(i
);
188 for (i
= 8*sizeof(word
) + 1; i
<= 16 * sizeof(word
); i
++) {
189 GC_size_map
[i
] = (ROUNDED_UP_WORDS(i
) + 1) & (~1);
191 # ifdef GC_GCJ_SUPPORT
192 /* Make all sizes up to 32 words predictable, so that a */
193 /* compiler can statically perform the same computation, */
194 /* or at least a computation that results in similar size */
196 for (i
= 16*sizeof(word
) + 1; i
<= 32 * sizeof(word
); i
++) {
197 GC_size_map
[i
] = (ROUNDED_UP_WORDS(i
) + 3) & (~3);
200 /* We leave the rest of the array to be filled in on demand. */
203 /* Fill in additional entries in GC_size_map, including the ith one */
204 /* We assume the ith entry is currently 0. */
205 /* Note that a filled in section of the array ending at n always */
206 /* has length at least n/4. */
207 void GC_extend_size_map(i
)
210 word orig_word_sz
= ROUNDED_UP_WORDS(i
);
211 word word_sz
= orig_word_sz
;
212 register word byte_sz
= WORDS_TO_BYTES(word_sz
);
213 /* The size we try to preserve. */
214 /* Close to to i, unless this would */
215 /* introduce too many distinct sizes. */
216 word smaller_than_i
= byte_sz
- (byte_sz
>> 3);
217 word much_smaller_than_i
= byte_sz
- (byte_sz
>> 2);
218 register word low_limit
; /* The lowest indexed entry we */
222 if (GC_size_map
[smaller_than_i
] == 0) {
223 low_limit
= much_smaller_than_i
;
224 while (GC_size_map
[low_limit
] != 0) low_limit
++;
226 low_limit
= smaller_than_i
+ 1;
227 while (GC_size_map
[low_limit
] != 0) low_limit
++;
228 word_sz
= ROUNDED_UP_WORDS(low_limit
);
229 word_sz
+= word_sz
>> 3;
230 if (word_sz
< orig_word_sz
) word_sz
= orig_word_sz
;
236 if (word_sz
> MAXOBJSZ
) {
239 /* If we can fit the same number of larger objects in a block, */
242 size_t number_of_objs
= BODY_SZ
/word_sz
;
243 word_sz
= BODY_SZ
/number_of_objs
;
248 byte_sz
= WORDS_TO_BYTES(word_sz
);
249 if (GC_all_interior_pointers
) {
250 /* We need one extra byte; don't fill in GC_size_map[byte_sz] */
251 byte_sz
-= EXTRA_BYTES
;
254 for (j
= low_limit
; j
<= byte_sz
; j
++) GC_size_map
[j
] = word_sz
;
260 * The following is a gross hack to deal with a problem that can occur
261 * on machines that are sloppy about stack frame sizes, notably SPARC.
262 * Bogus pointers may be written to the stack and not cleared for
263 * a LONG time, because they always fall into holes in stack frames
264 * that are not written. We partially address this by clearing
265 * sections of the stack whenever we get control.
267 word GC_stack_last_cleared
= 0; /* GC_no when we last did this */
269 # define BIG_CLEAR_SIZE 2048 /* Clear this much now and then. */
270 # define SMALL_CLEAR_SIZE 256 /* Clear this much every time. */
272 # define CLEAR_SIZE 213 /* Granularity for GC_clear_stack_inner */
273 # define DEGRADE_RATE 50
275 word GC_min_sp
; /* Coolest stack pointer value from which we've */
276 /* already cleared the stack. */
279 /* "hottest" stack pointer value we have seen */
280 /* recently. Degrades over time. */
282 word GC_words_allocd_at_reset
;
284 #if defined(ASM_CLEAR_CODE)
285 extern ptr_t
GC_clear_stack_inner();
287 /* Clear the stack up to about limit. Return arg. */
289 ptr_t
GC_clear_stack_inner(arg
, limit
)
293 word dummy
[CLEAR_SIZE
];
295 BZERO(dummy
, CLEAR_SIZE
*sizeof(word
));
296 if ((word
)(dummy
) COOLER_THAN limit
) {
297 (void) GC_clear_stack_inner(arg
, limit
);
299 /* Make sure the recursive call is not a tail call, and the bzero */
300 /* call is not recognized as dead code. */
301 GC_noop1((word
)dummy
);
306 /* Clear some of the inaccessible part of the stack. Returns its */
307 /* argument, so it can be used in a tail call position, hence clearing */
309 ptr_t
GC_clear_stack(arg
)
312 register word sp
= (word
)GC_approx_sp(); /* Hotter than actual sp */
314 word dummy
[SMALL_CLEAR_SIZE
];
315 static unsigned random_no
= 0;
316 /* Should be more random than it is ... */
317 /* Used to occasionally clear a bigger */
323 /* Extra bytes we clear every time. This clears our own */
324 /* activation record, and should cause more frequent */
325 /* clearing near the cold end of the stack, a good thing. */
326 # define GC_SLOP 4000
327 /* We make GC_high_water this much hotter than we really saw */
328 /* saw it, to cover for GC noise etc. above our current frame. */
329 # define CLEAR_THRESHOLD 100000
330 /* We restart the clearing process after this many bytes of */
331 /* allocation. Otherwise very heavily recursive programs */
332 /* with sparse stacks may result in heaps that grow almost */
333 /* without bounds. As the heap gets larger, collection */
334 /* frequency decreases, thus clearing frequency would decrease, */
335 /* thus more junk remains accessible, thus the heap gets */
338 if (++random_no
% 13 == 0) {
340 MAKE_HOTTER(limit
, BIG_CLEAR_SIZE
*sizeof(word
));
341 limit
&= ~0xf; /* Make it sufficiently aligned for assembly */
342 /* implementations of GC_clear_stack_inner. */
343 return GC_clear_stack_inner(arg
, limit
);
345 BZERO(dummy
, SMALL_CLEAR_SIZE
*sizeof(word
));
349 if (GC_gc_no
> GC_stack_last_cleared
) {
350 /* Start things over, so we clear the entire stack again */
351 if (GC_stack_last_cleared
== 0) GC_high_water
= (word
) GC_stackbottom
;
352 GC_min_sp
= GC_high_water
;
353 GC_stack_last_cleared
= GC_gc_no
;
354 GC_words_allocd_at_reset
= GC_words_allocd
;
356 /* Adjust GC_high_water */
357 MAKE_COOLER(GC_high_water
, WORDS_TO_BYTES(DEGRADE_RATE
) + GC_SLOP
);
358 if (sp HOTTER_THAN GC_high_water
) {
361 MAKE_HOTTER(GC_high_water
, GC_SLOP
);
363 MAKE_HOTTER(limit
, SLOP
);
364 if (sp COOLER_THAN limit
) {
365 limit
&= ~0xf; /* Make it sufficiently aligned for assembly */
366 /* implementations of GC_clear_stack_inner. */
368 return(GC_clear_stack_inner(arg
, limit
));
369 } else if (WORDS_TO_BYTES(GC_words_allocd
- GC_words_allocd_at_reset
)
371 /* Restart clearing process, but limit how much clearing we do. */
373 MAKE_HOTTER(GC_min_sp
, CLEAR_THRESHOLD
/4);
374 if (GC_min_sp HOTTER_THAN GC_high_water
) GC_min_sp
= GC_high_water
;
375 GC_words_allocd_at_reset
= GC_words_allocd
;
382 /* Return a pointer to the base address of p, given a pointer to a */
383 /* an address within an object. Return 0 o.w. */
385 GC_PTR
GC_base(GC_PTR p
)
392 register struct hblk
*h
;
393 register bottom_index
*bi
;
394 register hdr
*candidate_hdr
;
398 if (!GC_is_initialized
) return 0;
401 candidate_hdr
= HDR_FROM_BI(bi
, r
);
402 if (candidate_hdr
== 0) return(0);
403 /* If it's a pointer to the middle of a large object, move it */
404 /* to the beginning. */
405 while (IS_FORWARDING_ADDR_OR_NIL(candidate_hdr
)) {
406 h
= FORWARDED_ADDR(h
,candidate_hdr
);
408 candidate_hdr
= HDR(h
);
410 if (candidate_hdr
-> hb_map
== GC_invalid_map
) return(0);
411 /* Make sure r points to the beginning of the object */
412 r
&= ~(WORDS_TO_BYTES(1) - 1);
414 register int offset
= HBLKDISPL(r
);
415 register signed_word sz
= candidate_hdr
-> hb_sz
;
416 register signed_word map_entry
;
418 map_entry
= MAP_ENTRY((candidate_hdr
-> hb_map
), offset
);
419 if (map_entry
> CPP_MAX_OFFSET
) {
420 map_entry
= (signed_word
)(BYTES_TO_WORDS(offset
)) % sz
;
422 r
-= WORDS_TO_BYTES(map_entry
);
423 limit
= r
+ WORDS_TO_BYTES(sz
);
424 if (limit
> (word
)(h
+ 1)
425 && sz
<= BYTES_TO_WORDS(HBLKSIZE
)) {
428 if ((word
)p
>= limit
) return(0);
434 /* Return the size of an object, given a pointer to its base. */
435 /* (For small obects this also happens to work from interior pointers, */
436 /* but that shouldn't be relied upon.) */
438 size_t GC_size(GC_PTR p
)
445 register hdr
* hhdr
= HDR(p
);
447 sz
= WORDS_TO_BYTES(hhdr
-> hb_sz
);
451 size_t GC_get_heap_size
GC_PROTO(())
453 return ((size_t) GC_heapsize
);
456 size_t GC_get_free_bytes
GC_PROTO(())
458 return ((size_t) GC_large_free_bytes
);
461 size_t GC_get_bytes_since_gc
GC_PROTO(())
463 return ((size_t) WORDS_TO_BYTES(GC_words_allocd
));
466 size_t GC_get_total_bytes
GC_PROTO(())
468 return ((size_t) WORDS_TO_BYTES(GC_words_allocd
+GC_words_allocd_before_gc
));
471 GC_bool GC_is_initialized
= FALSE
;
479 #if defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS)
480 if (!GC_is_initialized
) {
481 BOOL (WINAPI
*pfn
) (LPCRITICAL_SECTION
, DWORD
) = NULL
;
482 HMODULE hK32
= GetModuleHandle(_T("kernel32.dll"));
484 pfn
= GetProcAddress(hK32
,
485 "InitializeCriticalSectionAndSpinCount");
487 pfn(&GC_allocate_ml
, 4000);
489 InitializeCriticalSection (&GC_allocate_ml
);
498 # if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC)
499 /* Make sure marker threads and started and thread local */
500 /* allocation is initialized, in case we didn't get */
501 /* called from GC_init_parallel(); */
503 extern void GC_init_parallel(void);
506 # endif /* PARALLEL_MARK || THREAD_LOCAL_ALLOC */
508 # if defined(DYNAMIC_LOADING) && defined(DARWIN)
510 /* This must be called WITHOUT the allocation lock held
511 and before any threads are created */
512 extern void GC_init_dyld();
518 #if defined(MSWIN32) || defined(MSWINCE)
519 CRITICAL_SECTION GC_write_cs
;
523 extern void GC_init_win32
GC_PROTO((void));
526 extern void GC_setpagesize();
530 extern GC_bool GC_no_win32_dlls
;
532 # define GC_no_win32_dlls FALSE
535 void GC_exit_check
GC_PROTO((void))
540 #ifdef SEARCH_FOR_DATA_START
541 extern void GC_init_linux_data_start
GC_PROTO((void));
546 extern void GC_set_and_save_fault_handler
GC_PROTO((void (*handler
)(int)));
548 static void looping_handler(sig
)
551 GC_err_printf1("Caught signal %d: looping in handler\n", sig
);
555 static GC_bool installed_looping_handler
= FALSE
;
557 static void maybe_install_looping_handler()
559 /* Install looping handler before the write fault handler, so we */
560 /* handle write faults correctly. */
561 if (!installed_looping_handler
&& 0 != GETENV("GC_LOOP_ON_ABORT")) {
562 GC_set_and_save_fault_handler(looping_handler
);
563 installed_looping_handler
= TRUE
;
567 #else /* !UNIX_LIKE */
569 # define maybe_install_looping_handler()
575 # if !defined(THREADS) && defined(GC_ASSERTIONS)
578 word initial_heap_sz
= (word
)MINHINCR
;
580 if (GC_is_initialized
) return;
584 # if defined(MSWIN32) || defined(MSWINCE)
585 InitializeCriticalSection(&GC_write_cs
);
587 if (0 != GETENV("GC_PRINT_STATS")) {
590 # ifndef NO_DEBUGGING
591 if (0 != GETENV("GC_DUMP_REGULARLY")) {
592 GC_dump_regularly
= 1;
595 # ifdef KEEP_BACK_PTRS
597 char * backtraces_string
= GETENV("GC_BACKTRACES");
598 if (0 != backtraces_string
) {
599 GC_backtraces
= atol(backtraces_string
);
600 if (backtraces_string
[0] == '\0') GC_backtraces
= 1;
604 if (0 != GETENV("GC_FIND_LEAK")) {
607 atexit(GC_exit_check
);
610 if (0 != GETENV("GC_ALL_INTERIOR_POINTERS")) {
611 GC_all_interior_pointers
= 1;
613 if (0 != GETENV("GC_DONT_GC")) {
616 if (0 != GETENV("GC_PRINT_BACK_HEIGHT")) {
617 GC_print_back_height
= 1;
619 if (0 != GETENV("GC_NO_BLACKLIST_WARNING")) {
620 GC_large_alloc_warn_interval
= LONG_MAX
;
623 char * time_limit_string
= GETENV("GC_PAUSE_TIME_TARGET");
624 if (0 != time_limit_string
) {
625 long time_limit
= atol(time_limit_string
);
626 if (time_limit
< 5) {
627 WARN("GC_PAUSE_TIME_TARGET environment variable value too small "
628 "or bad syntax: Ignoring\n", 0);
630 GC_time_limit
= time_limit
;
635 char * interval_string
= GETENV("GC_LARGE_ALLOC_WARN_INTERVAL");
636 if (0 != interval_string
) {
637 long interval
= atol(interval_string
);
639 WARN("GC_LARGE_ALLOC_WARN_INTERVAL environment variable has "
640 "bad value: Ignoring\n", 0);
642 GC_large_alloc_warn_interval
= interval
;
646 maybe_install_looping_handler();
647 /* Adjust normal object descriptor for extra allocation. */
648 if (ALIGNMENT
> GC_DS_TAGS
&& EXTRA_BYTES
!= 0) {
649 GC_obj_kinds
[NORMAL
].ok_descriptor
= ((word
)(-ALIGNMENT
) | GC_DS_LENGTH
);
652 GC_exclude_static_roots(beginGC_arrays
, endGC_arrays
);
653 GC_exclude_static_roots(beginGC_obj_kinds
, endGC_obj_kinds
);
654 # ifdef SEPARATE_GLOBALS
655 GC_exclude_static_roots(beginGC_objfreelist
, endGC_objfreelist
);
656 GC_exclude_static_roots(beginGC_aobjfreelist
, endGC_aobjfreelist
);
661 # if defined(SEARCH_FOR_DATA_START)
662 GC_init_linux_data_start();
664 # if (defined(NETBSD) || defined(OPENBSD)) && defined(__ELF__)
665 GC_init_netbsd_elf();
667 # if defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS) \
668 || defined(GC_WIN32_THREADS)
671 # ifdef GC_SOLARIS_THREADS
672 /* We need dirty bits in order to find live stack sections. */
675 # if !defined(THREADS) || defined(GC_PTHREADS) || defined(GC_WIN32_THREADS) \
676 || defined(GC_SOLARIS_THREADS)
677 if (GC_stackbottom
== 0) {
678 GC_stackbottom
= GC_get_stack_base();
679 # if (defined(LINUX) || defined(HPUX)) && defined(IA64)
680 GC_register_stackbottom
= GC_get_register_stack_base();
683 # if (defined(LINUX) || defined(HPUX)) && defined(IA64)
684 if (GC_register_stackbottom
== 0) {
685 WARN("GC_register_stackbottom should be set with GC_stackbottom", 0);
686 /* The following may fail, since we may rely on */
687 /* alignment properties that may not hold with a user set */
688 /* GC_stackbottom. */
689 GC_register_stackbottom
= GC_get_register_stack_base();
694 GC_STATIC_ASSERT(sizeof (ptr_t
) == sizeof(word
));
695 GC_STATIC_ASSERT(sizeof (signed_word
) == sizeof(word
));
696 GC_STATIC_ASSERT(sizeof (struct hblk
) == HBLKSIZE
);
698 # if defined(STACK_GROWS_UP) && defined(STACK_GROWS_DOWN)
700 "Only one of STACK_GROWS_UP and STACK_GROWS_DOWN should be defd\n");
702 # if !defined(STACK_GROWS_UP) && !defined(STACK_GROWS_DOWN)
704 "One of STACK_GROWS_UP and STACK_GROWS_DOWN should be defd\n");
706 # ifdef STACK_GROWS_DOWN
707 GC_ASSERT((word
)(&dummy
) <= (word
)GC_stackbottom
);
709 GC_ASSERT((word
)(&dummy
) >= (word
)GC_stackbottom
);
712 # if !defined(_AUX_SOURCE) || defined(__GNUC__)
713 GC_ASSERT((word
)(-1) > (word
)0);
714 /* word should be unsigned */
716 GC_ASSERT((signed_word
)(-1) < (signed_word
)0);
718 /* Add initial guess of root sets. Do this first, since sbrk(0) */
720 if (GC_REGISTER_MAIN_STATIC_DATA()) GC_register_data_segments();
725 char * sz_str
= GETENV("GC_INITIAL_HEAP_SIZE");
726 if (sz_str
!= NULL
) {
727 initial_heap_sz
= atoi(sz_str
);
728 if (initial_heap_sz
<= MINHINCR
* HBLKSIZE
) {
729 WARN("Bad initial heap size %s - ignoring it.\n",
732 initial_heap_sz
= divHBLKSZ(initial_heap_sz
);
736 char * sz_str
= GETENV("GC_MAXIMUM_HEAP_SIZE");
737 if (sz_str
!= NULL
) {
738 word max_heap_sz
= (word
)atol(sz_str
);
739 if (max_heap_sz
< initial_heap_sz
* HBLKSIZE
) {
740 WARN("Bad maximum heap size %s - ignoring it.\n",
743 if (0 == GC_max_retries
) GC_max_retries
= 2;
744 GC_set_max_heap_size(max_heap_sz
);
747 if (!GC_expand_hp_inner(initial_heap_sz
)) {
748 GC_err_printf0("Can't start up: not enough memory\n");
751 /* Preallocate large object map. It's otherwise inconvenient to */
752 /* deal with failure. */
753 if (!GC_add_map_entry((word
)0)) {
754 GC_err_printf0("Can't start up: not enough memory\n");
757 GC_register_displacement_inner(0L);
762 if (PCR_IL_Lock(PCR_Bool_false
, PCR_allSigsBlocked
, PCR_waitForever
)
764 ABORT("Can't lock load state\n");
765 } else if (PCR_IL_Unlock() != PCR_ERes_okay
) {
766 ABORT("Can't unlock load state\n");
771 # if !defined(SMALL_CONFIG)
772 if (!GC_no_win32_dlls
&& 0 != GETENV("GC_ENABLE_INCREMENTAL")) {
773 GC_ASSERT(!GC_incremental
);
775 # ifndef GC_SOLARIS_THREADS
778 GC_ASSERT(GC_words_allocd
== 0)
779 GC_incremental
= TRUE
;
781 # endif /* !SMALL_CONFIG */
783 /* Get black list set up and/or incremental GC started */
784 if (!GC_dont_precollect
|| GC_incremental
) GC_gcollect_inner();
785 GC_is_initialized
= TRUE
;
786 # ifdef STUBBORN_ALLOC
789 /* Convince lint that some things are used */
792 extern char * GC_copyright
[];
793 extern int GC_read();
794 extern void GC_register_finalizer_no_order();
796 GC_noop(GC_copyright
, GC_find_header
,
797 GC_push_one
, GC_call_with_alloc_lock
, GC_read
,
799 # ifndef NO_DEBUGGING
802 GC_register_finalizer_no_order
);
807 void GC_enable_incremental
GC_PROTO(())
809 # if !defined(SMALL_CONFIG) && !defined(KEEP_BACK_PTRS)
810 /* If we are keeping back pointers, the GC itself dirties all */
811 /* pages on which objects have been marked, making */
812 /* incremental GC pointless. */
818 if (GC_incremental
) goto out
;
820 if (GC_no_win32_dlls
) goto out
;
821 # ifndef GC_SOLARIS_THREADS
822 maybe_install_looping_handler(); /* Before write fault handler! */
825 if (!GC_is_initialized
) {
828 if (GC_incremental
) goto out
;
830 /* Can't easily do it. */
835 if (GC_words_allocd
> 0) {
836 /* There may be unmarked reachable objects */
838 } /* else we're OK in assuming everything's */
839 /* clean since nothing can point to an */
840 /* unmarked object. */
842 GC_incremental
= TRUE
;
851 #if defined(MSWIN32) || defined(MSWINCE)
852 # define LOG_FILE _T("gc.log")
854 HANDLE GC_stdout
= 0;
858 if (GC_is_initialized
) {
859 DeleteCriticalSection(&GC_write_cs
);
863 int GC_write(buf
, len
)
871 EnterCriticalSection(&GC_write_cs
);
872 if (GC_stdout
== INVALID_HANDLE_VALUE
) {
874 } else if (GC_stdout
== 0) {
875 GC_stdout
= CreateFile(LOG_FILE
, GENERIC_WRITE
,
876 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
877 NULL
, CREATE_ALWAYS
, FILE_FLAG_WRITE_THROUGH
,
879 if (GC_stdout
== INVALID_HANDLE_VALUE
) ABORT("Open of log file failed");
881 tmp
= WriteFile(GC_stdout
, buf
, len
, &written
, NULL
);
884 LeaveCriticalSection(&GC_write_cs
);
885 return tmp
? (int)written
: -1;
890 #if defined(OS2) || defined(MACOS)
891 FILE * GC_stdout
= NULL
;
892 FILE * GC_stderr
= NULL
;
893 int GC_tmp
; /* Should really be local ... */
897 if (GC_stdout
== NULL
) {
900 if (GC_stderr
== NULL
) {
906 #if !defined(OS2) && !defined(MACOS) && !defined(MSWIN32) && !defined(MSWINCE)
914 #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(OS2) \
915 && !defined(MACOS) && !defined(ECOS) && !defined(NOSYS)
916 int GC_write(fd
, buf
, len
)
921 register int bytes_written
= 0;
924 while (bytes_written
< len
) {
925 # ifdef GC_SOLARIS_THREADS
926 result
= syscall(SYS_write
, fd
, buf
+ bytes_written
,
927 len
- bytes_written
);
929 result
= write(fd
, buf
+ bytes_written
, len
- bytes_written
);
931 if (-1 == result
) return(result
);
932 bytes_written
+= result
;
934 return(bytes_written
);
939 int GC_write(fd
, buf
, len
)
941 _Jv_diag_write (buf
, len
);
947 int GC_write(fd
, buf
, len
)
955 #if defined(MSWIN32) || defined(MSWINCE)
956 # define WRITE(f, buf, len) GC_write(buf, len)
958 # if defined(OS2) || defined(MACOS)
959 # define WRITE(f, buf, len) (GC_set_files(), \
960 GC_tmp = fwrite((buf), 1, (len), (f)), \
963 # define WRITE(f, buf, len) GC_write((f), (buf), (len))
967 /* A version of printf that is unlikely to call malloc, and is thus safer */
968 /* to call from the collector in case malloc has been bound to GC_malloc. */
969 /* Assumes that no more than 1023 characters are written at once. */
970 /* Assumes that all arguments have been converted to something of the */
971 /* same size as long, and that the format conversions expect something */
973 void GC_printf(format
, a
, b
, c
, d
, e
, f
)
974 GC_CONST
char * format
;
975 long a
, b
, c
, d
, e
, f
;
979 if (GC_quiet
) return;
981 (void) sprintf(buf
, format
, a
, b
, c
, d
, e
, f
);
982 if (buf
[1024] != 0x15) ABORT("GC_printf clobbered stack");
983 if (WRITE(GC_stdout
, buf
, strlen(buf
)) < 0) ABORT("write to stdout failed");
986 void GC_err_printf(format
, a
, b
, c
, d
, e
, f
)
987 GC_CONST
char * format
;
988 long a
, b
, c
, d
, e
, f
;
993 (void) sprintf(buf
, format
, a
, b
, c
, d
, e
, f
);
994 if (buf
[1024] != 0x15) ABORT("GC_err_printf clobbered stack");
995 if (WRITE(GC_stderr
, buf
, strlen(buf
)) < 0) ABORT("write to stderr failed");
1001 if (WRITE(GC_stderr
, s
, strlen(s
)) < 0) ABORT("write to stderr failed");
1004 #if defined(LINUX) && !defined(SMALL_CONFIG)
1005 void GC_err_write(buf
, len
)
1009 if (WRITE(GC_stderr
, buf
, len
) < 0) ABORT("write to stderr failed");
1013 # if defined(__STDC__) || defined(__cplusplus)
1014 void GC_default_warn_proc(char *msg
, GC_word arg
)
1016 void GC_default_warn_proc(msg
, arg
)
1021 GC_err_printf1(msg
, (unsigned long)arg
);
1024 GC_warn_proc GC_current_warn_proc
= GC_default_warn_proc
;
1026 # if defined(__STDC__) || defined(__cplusplus)
1027 GC_warn_proc
GC_set_warn_proc(GC_warn_proc p
)
1029 GC_warn_proc
GC_set_warn_proc(p
)
1033 GC_warn_proc result
;
1035 # ifdef GC_WIN32_THREADS
1036 GC_ASSERT(GC_is_initialized
);
1039 result
= GC_current_warn_proc
;
1040 GC_current_warn_proc
= p
;
1045 # if defined(__STDC__) || defined(__cplusplus)
1046 GC_word
GC_set_free_space_divisor (GC_word value
)
1048 GC_word
GC_set_free_space_divisor (value
)
1052 GC_word old
= GC_free_space_divisor
;
1053 GC_free_space_divisor
= value
;
1059 GC_CONST
char * msg
;
1061 # if defined(MSWIN32)
1062 (void) MessageBoxA(NULL
, msg
, "Fatal error in gc", MB_ICONERROR
|MB_OK
);
1064 GC_err_printf1("%s\n", msg
);
1066 if (GETENV("GC_LOOP_ON_ABORT") != NULL
) {
1067 /* In many cases it's easier to debug a running process. */
1068 /* It's arguably nicer to sleep, but that makes it harder */
1069 /* to look at the thread if the debugger doesn't know much */
1070 /* about threads. */
1073 # if defined(MSWIN32) || defined(MSWINCE)
1095 /* Helper procedures for new kind creation. */
1096 void ** GC_new_free_list_inner()
1098 void *result
= GC_INTERNAL_MALLOC((MAXOBJSZ
+1)*sizeof(ptr_t
), PTRFREE
);
1099 if (result
== 0) ABORT("Failed to allocate freelist for new kind");
1100 BZERO(result
, (MAXOBJSZ
+1)*sizeof(ptr_t
));
1104 void ** GC_new_free_list()
1107 LOCK(); DISABLE_SIGNALS();
1108 result
= GC_new_free_list_inner();
1109 UNLOCK(); ENABLE_SIGNALS();
1113 int GC_new_kind_inner(fl
, descr
, adjust
, clear
)
1119 int result
= GC_n_kinds
++;
1121 if (GC_n_kinds
> MAXOBJKINDS
) ABORT("Too many kinds");
1122 GC_obj_kinds
[result
].ok_freelist
= (ptr_t
*)fl
;
1123 GC_obj_kinds
[result
].ok_reclaim_list
= 0;
1124 GC_obj_kinds
[result
].ok_descriptor
= descr
;
1125 GC_obj_kinds
[result
].ok_relocate_descr
= adjust
;
1126 GC_obj_kinds
[result
].ok_init
= clear
;
1130 int GC_new_kind(fl
, descr
, adjust
, clear
)
1137 LOCK(); DISABLE_SIGNALS();
1138 result
= GC_new_kind_inner(fl
, descr
, adjust
, clear
);
1139 UNLOCK(); ENABLE_SIGNALS();
1143 int GC_new_proc_inner(proc
)
1146 int result
= GC_n_mark_procs
++;
1148 if (GC_n_mark_procs
> MAX_MARK_PROCS
) ABORT("Too many mark procedures");
1149 GC_mark_procs
[result
] = proc
;
1153 int GC_new_proc(proc
)
1157 LOCK(); DISABLE_SIGNALS();
1158 result
= GC_new_proc_inner(proc
);
1159 UNLOCK(); ENABLE_SIGNALS();
1164 #if !defined(NO_DEBUGGING)
1168 GC_printf0("***Static roots:\n");
1169 GC_print_static_roots();
1170 GC_printf0("\n***Heap sections:\n");
1171 GC_print_heap_sects();
1172 GC_printf0("\n***Free blocks:\n");
1173 GC_print_hblkfreelist();
1174 GC_printf0("\n***Blocks in use:\n");
1175 GC_print_block_list();
1176 GC_printf0("\n***Finalization statistics:\n");
1177 GC_print_finalization_stats();
1180 #endif /* NO_DEBUGGING */