X-Git-Url: http://wien.tomnetworks.com/gitweb/?p=hs-boehmgc.git;a=blobdiff_plain;f=gc-7.2%2FChangeLog;fp=gc-7.2%2FChangeLog;h=1c3a3260ca171e01f9c637565d14a5193ed9f238;hp=0000000000000000000000000000000000000000;hb=324587ba93dc77f37406d41fd2a20d0e0d94fb1d;hpb=2a4ea609491b225a1ceb06da70396e93916f137a diff --git a/gc-7.2/ChangeLog b/gc-7.2/ChangeLog new file mode 100644 index 0000000..1c3a326 --- /dev/null +++ b/gc-7.2/ChangeLog @@ -0,0 +1,8153 @@ +[7.2d] + +2012-08-09 Ivan Maidanski + + * doc/README: Change version to 7.2d (rev. D). + +2012-08-05 Ivan Maidanski + + * config.guess: Regenerate (by autoreconf -vif using autoconf-2.68, + automake-1.11.1 and libtool-2.4). + * config.sub: Likewise. + * m4/libtool.m4: Likewise. + +2012-08-02 Ivan Maidanski + + * misc.c (GC_clear_stack_inner): Use GC_approx_sp() instead of + "dummy[0]" set to "&dummy" value (that worked as expected only for + STACK_GROWS_DOWN case). + +2012-08-02 Ivan Maidanski + + * alloc.c (min_bytes_allocd, GC_stopped_mark): Use GC_approx_sp() + instead of "&dummy"; remove 'dummy' local variable. + * dyn_load.c (GC_cond_add_roots): Likewise. + * misc.c (GC_init): Likewise. + * os_dep.c (GC_get_stack_base, GC_get_main_stack_base): Likewise. + * pthread_stop_world.c (GC_suspend_handler_inner, + nacl_pre_syscall_hook, __nacl_suspend_thread_if_needed): Likewise. + * pthread_support.c (GC_thr_init): Likewise. + * ptr_chck.c (GC_on_stack): Likewise. + * win32_threads.c (GC_push_stack_for): Likewise. + * extra/setjmp_t.c (main): Define volatile 'sp' local variable, store + its address to it and use it instead of "&dummy"; remove 'dummy' local + variable. + * mach_dep.c (GC_with_callee_saves_pushed): Use volatile for 'dummy' + local variable. + * misc.c (GC_clear_stack_inner): Store address of volatile 'dummy' + local array (i.e. 'sp' value) to its first element (and use it in the + comparison of addresses) to prevent any harmful optimizations as C + officially disallows comparisons of pointers to different objects + (e.g., some Mac OS X clang releases might turn a conditional + expression that uses 'dummy' address into a constant); update comment. + * misc.c (GC_call_with_stack_base): Use "&base" instead of "&dummy" + (it is safe to use address of base here); remove dummy variable. + +2012-08-01 Ivan Maidanski + + * misc.c (GC_call_with_stack_base): Call GC_noop1 after fn() + invocation to prevent a tail-call optimization. + +2012-07-21 Ivan Maidanski + + * os_dep.c (GC_get_stack_base): Abort if pthread_stackseg_np fails + (if GC_OPENBSD_THREADS). + * pthread_stop_world.c (GC_suspend_all): Get correct stack_ptr by + calling pthread_stackseg_np (subtracting ss_size from ss_sp) instead + of retrieving it from OpenBSD pthread implementation-dependent context + (if GC_OPENBSD_THREADS); remove comment. + +2012-06-17 Ivan Maidanski + + * tests/initsecondarythread.c: Include "private/config.h" if + HAVE_CONFIG_H (mostly to have GC_WIN32_PTHREADS defined for + pthreads-w32 target). + * tests/thread_leak_test.c: Likewise. + * tests/threadkey_test.c: Likewise. + +2012-06-16 Ivan Maidanski + + * tests/test_cpp.cc (WinMain): Prevent SEGV in strtok() by checking + "cmd" WinMain argument for NULL (in that case "argc" local variable is + set to 0). + +2012-06-16 Ivan Maidanski + + * tests/test_cpp.cc (main): Call GC_set_all_interior_pointers(1) + before GC_INIT to ensure that the collector considers pointers to + object interiors as valid ones (such a pointer could emerge as + a result of a type cast to subclass in case of multiple inheritance); + add comment. + +[7.2c] + +2012-06-11 Ivan Maidanski + + * doc/README: Change version to 7.2c (rev. C). + +2012-06-08 Ivan Maidanski + + * cordbscs.c (CORD_cat_char_star): Check GC_MALLOC_ATOMIC result for + NULL (do OUT_OF_MEMORY in such case) to prevent SEGV. + +2012-06-07 Ivan Maidanski + + * dyn_load.c (GC_register_dynamic_libraries): If GC_scratch_alloc + fails (returns null) then abort (with the appropriate message) instead + of causing SEGV. + * os_dep.c (GC_dirty_init): Likewise. + * headers.c (GC_init_headers): Report error and exit if + GC_scratch_alloc fails. + * include/private/gc_priv.h (GC_scratch_alloc): Improve comment. + * os_dep.c (GC_print_address_map): If GC_get_maps return null then + print the appropriate message (instead of passing null to GC_err_puts + thus causing SEGV). + +2012-06-02 Ivan Maidanski + + * include/private/gc_priv.h (GC_push_all, GC_push_other_roots): + Declare as GC_API_PRIV (instead of GC_INNER) to make the symbol + externally visible to some well-known 3rd-party software (e.g., ECL). + * include/private/gc_priv.h (GC_push_conditional): Declare as + GC_API_PRIV (only if GC_DISABLE_INCREMENTAL is undefined). + * mark.c (GC_push_all, GC_push_conditional): Remove GC_INNER (to match + the declaration). + * os_dep.c (GC_push_other_roots): Likewise. + +2012-06-02 Ivan Maidanski + + * include/private/gc_priv.h (GC_clear_mark_bit, GC_set_mark_bit): + Declare as GC_API_PRIV (instead of GC_INNER) to make the symbol + externally visible to 3rd-party software (e.g., ECL). + * mark.c (GC_set_mark_bit, GC_clear_mark_bit): Remove GC_INNER (to + match the declaration). + +2012-06-01 Tsugutomo Enami + + * dyn_load.c: Include sys/param.h and dlfcn.h on NetBSD. + * dyn_load.c (GC_FirstDLOpenedLinkMap): Obtain link map using dlinfo() + on NetBSD if RTLD_DI_LINKMAP feature present (defined). + +[7.2b] + +2012-05-23 Ivan Maidanski + + * doc/README: Change version to 7.2b (rev. B). + +2012-05-16 Ivan Maidanski + + * malloc.c (GC_malloc_uncollectable): Do not check assertion on + hb_n_marks to be zero if multi-threaded; add comment. + * mallocx.c (GC_malloc_atomic_uncollectable): Likewise. + +[7.2] + +2012-05-11 Ivan Maidanski + + * configure.ac, doc/README, include/gc_version.h: + Bump version to 7.2 (final). + * configure: Regenerate. + * Makefile.in: Ditto. + +2012-04-16 H.J. Lu + + * include/gc_tiny_fl.h (GC_GRANULE_BYTES): Set to 8 for x32. + (GC_GRANULE_WORDS): Set to 2 for x32. + +2012-04-16 H.J. Lu + + * include/private/gcconfig.h: (ALIGNMENT): Set to 4 for x32. + (CPP_WORDSZ): Set to 32 for x32. + +2012-04-29 Ivan Maidanski + + * alloc.c (GC_check_fl_marks): Cast pointer passed to GC_is_marked to + prevent compiler warning. + +2012-04-21 Petter Urkedal + + * alloc.c (GC_check_fl_marks): Re-read each pointer atomically before + following the pointed-to link and bail out if the result is different + (this can happen if the thread has popped the object off the + free-list); the function is a no-op if AO_load is unavailable. + +2012-04-21 Ivan Maidanski + + * pthread_support.c (GC_remove_all_threads_but_me): Call + GC_remove_specific after destroying thread-local list. + +2012-04-20 Ivan Maidanski + + * alloc.c (GC_check_fl_marks): Change prototype (pass pointer to + "freelist" element instead of value); do not define the function if + THREAD_LOCAL_ALLOC undefined. + * include/private/gc_priv.h (GC_check_fl_marks): Likewise. + * alloc.c (GC_check_fl_marks): Skip check if the argument points to + a special (non-pointer) value; update comment; rename "q" local + variable to "list". + * thread_local_alloc.c (GC_check_tls_for): Update code according to + GC_check_fl_marks functionality change (remove checks for special + value). + +2012-04-17 Niklas Therning + + * include/private/gcconfig.h (HAVE_BUILTIN_UNWIND_INIT): Do not define + for clang (as __builtin_unwind_init seems to be a no-op in the latest + clang release). + +2012-04-12 Ivan Maidanski + + * include/private/pthread_support.h (DETACHED): Fix a typo in comment. + +2012-04-02 Ivan Maidanski + + * configure: Regenerate. + * include/private/config.h.in : Likewise. + +2012-04-02 Ivan Maidanski + + * doc/README.macros (NO_HANDLE_FORK): Replace back with HANDLE_FORK + and update. + * include/private/gcconfig.h (CAN_HANDLE_FORK): Define also for Darwin + in case of MPROTECT_VDB. + * misc.c (GC_set_handle_fork): Handle Darwin properly; add comment. + * os_dep.c (GC_dirty_init): Do not turn on GC_dirty_maintained for + Darwin if GC_handle_fork is on; add comment; remove FIXME. + * pthread_support.c (GC_fork_prepare_proc): Remove WARN for Darwin + (since GC_dirty_maintained is off in that case). + * pthread_support.c (GC_fork_child_proc): Remove comment (for Darwin). + +2012-04-02 Ivan Maidanski + + * include/gc.h (GC_set_handle_fork): New API function. + * misc.c (GC_set_handle_fork): Likewise. + * include/private/gc_priv.h (GC_handle_fork): New internal variable + declaration (only if CAN_HANDLE_FORK). + * misc.c (GC_handle_fork): New internal variable (defined only if + CAN_HANDLE_FORK); initialize to TRUE if HANDLE_FORK. + * include/private/gcconfig.h (HANDLE_FORK): Replace with + CAN_HANDLE_FORK. + * pthread_support.c (HANDLE_FORK): Likewise. + * win32_threads.c (HANDLE_FORK): Likewise. + * include/private/gcconfig.h (CAN_HANDLE_FORK): Always define macro if + HANDLE_FORK. + * pthread_support.c (GC_thr_init): Replace HANDLE_FORK with + CAN_HANDLE_FORK; call pthread_atfork only if GC_handle_fork; update + the comment. + * win32_threads.c (GC_thr_init): Likewise. + * tests/test.c (NO_TEST_HANDLE_FORK): Define new macro if fork + handling is not supported (or is a no-op) on the target. + * tests/test.c (INIT_FORK_SUPPORT): New macro (invoke + GC_set_handle_fork unless NO_TEST_HANDLE_FORK). + * tests/test.c (GC_OPT_INIT): New macro (defined to GC_INIT or empty). + * tests/test.c (GC_COND_INIT): Use INIT_FORK_SUPPORT and GC_OPT_INIT. + * tests/test.c (run_one_test): Test NO_TEST_HANDLE_FORK (instead of + target-specific macros). + * win32_threads.c (GC_remove_all_threads_but_me, GC_fork_prepare_proc, + GC_fork_parent_proc, GC_fork_child_proc): Do not test GC_PTHREADS. + * configure.ac (HANDLE_FORK, NO_HANDLE_FORK): Update message. + +2012-02-20 Ivan Maidanski + + * pthread_support.c (GC_thr_init): Abort on pthread_atfork failure + (only if HANDLE_FORK). + +2012-03-30 Ivan Maidanski + + * include/gc.h (GC_HAVE_GET_HEAP_USAGE_SAFE): Remove public HAVE_ + macro (since function availability could be determined by autotools); + update the comment. + +2012-03-27 Andy Wingo + + * configure.ac: Add --enable-handle-fork option; if explicitly passed, + enables or disables the pthread_atfork support; if not passed, the + default, as determined by gcconfig.h, is to enable HANDLE_FORK if it + is supported on the target platform. + +2012-03-28 Ivan Maidanski + + * doc/README.solaris2 (SOLARIS THREADS): Update. + * doc/overview.html: Remove information about Solaris old-style + threads support. + +2012-03-26 Ivan Maidanski + + * dyn_load.c: Fix a typo and improve comment (for Android). + +2012-03-25 Ivan Maidanski + + * include/gc_mark.h (GC_clear_stack): New API function. + * include/private/gc_priv.h (GC_clear_stack): Remove declaration. + * misc.c (GC_clear_stack): Replace GC_INNER with GC_API; add GC_CALL + calling conventions modifier. + +2012-03-25 Ivan Maidanski + + * allchblk.c (GC_hblkfreelist, GC_free_bytes): Do not define array as + STATIC again but only if GC_GCJ_SUPPORT (for GNU GCJ client). + * blacklst.c (GC_is_black_listed): Do not define as GC_INNER again + (for GNU GCJ client). + * include/private/gc_priv.h (GC_is_black_listed): Likewise. + * include/private/gc_priv.h (GC_hblkfreelist): Restore removed + declaration (but only if GC_GCJ_SUPPORT). + * reclaim.c (GC_n_set_marks): Do not define as STATIC again (for GCJ); + update the comment. + +2012-03-24 Ivan Maidanski + + * include/gc.h (HIDE_POINTER): Test GC_I_HIDE_POINTERS macro (as + a synonym to I_HIDE_POINTERS) again (remains for backward + compatibility only). + +2012-03-24 Ivan Maidanski + + * include/gc.h (GC_PTR): Add typedef again (for source-level backward + compatibility useful for clients currently using gcc_boehmgc or + mono_libgc). + +2012-03-16 Ivan Maidanski + + * tests/test.c (GC_ALPHA_VERSION): Define to GC_TMP_ALPHA_VERSION if + not defined by gc_version.h. + * extra/add_gc_prefix.c (GC_ALPHA_VERSION): Likewise. + * extra/gcname.c (GC_ALPHA_VERSION): Likewise. + +2012-03-15 Ivan Maidanski (really Hans Boehm) + + * malloc.c (GC_SQRT_SIZE_MAX): New macro. + * malloc.c (calloc): Add fast initial size overflow check to avoid + integer division for reasonably small values passed. + +2012-03-15 Ivan Maidanski + + * malloc.c: Include limits.h for SIZE_MAX. + * malloc.c (SIZE_MAX, calloc): Define GC_SIZE_MAX instead of SIZE_MAX. + +2012-03-15 Xi Wang + + * malloc.c (GC_generic_malloc): Check if the allocation size is + rounded to a smaller value. + * mallocx.c (GC_generic_malloc_ignore_off_page): Likewise. + +2012-03-15 Xi Wang + + * malloc.c (calloc): Check multiplication overflow in calloc(), + assuming REDIRECT_MALLOC. + +2012-03-06 Ivan Maidanski + + * include/private/gc_priv.h (GC_print_stats): Update the comment. + * tests/test.c (GC_print_stats, run_one_test, check_heap_stats): + Rename GC_print_stats to print_stats (since the former is used + internally by GC and not exported). + * tests/test.c (print_stats): Always define (either as a macro or + a static int variable) regardless of GC_DLL and SMALL_CONFIG. + * tests/test.c (INIT_PRINT_STATS): New macro (used to initialize + print_stats if needed); GETENV is used if needed and available. + * tests/test.c (GC_COND_INIT): Invoke INIT_PRINT_STATS. + +2012-03-06 Ivan Maidanski + + * misc.c: Include windows.h for Cygwin if GC_READ_ENV_FILE (required + for GC_envfile_init). + * misc.c (_MAX_PATH): Move definition to the place before the first + use (only Win32). + +2012-03-04 Ivan Maidanski + + * misc.c (GC_init): Add a workaround for clang/x64 (coming with + Xcode 4.3) which cannot process the static assertion on + ((ptr_t)-1 > 0) correctly. + +2012-02-27 Ivan Maidanski + + * win32_threads.c (GC_register_my_thread): Fix SEGV by setting "me" + to the newly-created thread GC descriptor (if lookup failed) before + altering flags of "me" (only if GC_PTHREADS); add comment (same as + in pthread_support.c). + +2012-02-27 Ivan Maidanski + + * os_dep.c (GC_SysVGetDataStart): Place "volatile" keyword for + "result" local variable properly. + +2012-02-26 Ivan Maidanski + + * win32_threads.c (GC_remove_all_threads_but_me): Update comment; + re-hash GC_threads map as thread Win32 Id in the child differs from + that in the parent; rename "id" local variable to "pthread_id". + * win32_threads.c (GC_remove_all_threads_but_me): Call + GC_setspecific (if THREAD_LOCAL_ALLOC) to re-assign Win32-based + thread-local pointer to 'tlfs' (identified by GC_thread_key) of the + current thread. + +2012-02-26 Ivan Maidanski + + * pthread_support.c (GC_remove_all_threads_but_me): Refine comment for + stop_info.mach_thread update. + * pthread_support.c (GC_remove_all_threads_but_me): Call + GC_setspecific (if THREAD_LOCAL_ALLOC) to re-assign thread-local + pointer to 'tlfs' (identified by GC_thread_key) of the current thread + (except for USE_CUSTOM_SPECIFIC). + +2012-02-25 Ivan Maidanski + + * configure: Regenerate. + +2012-02-25 Ivan Maidanski + + * configure.ac (win32_threads): Set variable for "mingw" target + (causing definition of "WIN32_THREADS" AM conditional which, in turn, + causes win32_threads.c to be compiled and put to libgc.a). + +2012-02-25 Ivan Maidanski + + * include/private/gc_priv.h (SIG_SUSPEND): Do not define for Cygwin + and pthreads-w32 (since signals are not used for threads + suspend/resume). + +2012-02-24 Ivan Maidanski + + * include/private/gcconfig.h (HANDLE_FORK): Define also for Cygwin + (but not for win32-pthreads). + * win32_threads.c: Include unistd.h if HANDLE_FORK (for + pthread_atfork). + * win32_threads.c (GC_wait_for_gc_completion): Add wait_for_all + argument. + * win32_threads.c (GC_unregister_my_thread, GC_thread_exit_proc): Pass + FALSE ("wait_for_all" argument) to GC_wait_for_gc_completion. + * win32_threads.c (GC_remove_all_threads_but_me, GC_fork_prepare_proc, + GC_fork_parent_proc, GC_fork_child_proc): New functions (similar to + that in pthread_support.c) if HANDLE_FORK. + * win32_threads.c (GC_thr_init): Invoke pthread_atfork if HANDLE_FORK. + +2012-02-24 Ivan Maidanski + + * os_dep.c (GC_dirty_init): Add FIXME regarding fork (Darwin). + * pthread_support.c (GC_remove_all_threads_but_me): Update mach_thread + for "me" (Darwin). + * pthread_support.c (GC_fork_prepare_proc): Output warning if + GC_dirty_maintained (if DARWIN and MPROTECT_VDB). + * pthread_support.c (GC_fork_prepare_proc, GC_fork_child_proc): Add + FIXME (for Darwin). + * tests/test.c (run_one_test): Do not test fork() for Darwin with + incremental mode on (if HANDLE_FORK); add FIXME. + +2012-02-21 Ivan Maidanski + + * win32_threads.c (GC_wait_for_gc_completion): Add function (similar + implementation as in pthread_support.c). + * win32_threads.c (GC_unregister_my_thread, GC_thread_exit_proc): + Call GC_wait_for_gc_completion to prevent collecting from unregistered + thread; remove FIXME. + +2012-02-21 Ivan Maidanski + + * tests/test.c: Include unistd.h for fork() declaration if HANDLE_FORK + (and THREADS). + +2012-02-20 Ivan Maidanski (mostly really Andy Wingo) + + * doc/README.macros (HANDLE_FORK): Replace with NO_HANDLE_FORK; update + the documentation. + * include/private/gcconfig.h (HANDLE_FORK): Explicitly define if + GC_PTHREADS unless already defined or NO_HANDLE_FORK is defined, or + unsupported on the target. + +2012-02-16 Ivan Maidanski + + * mark.c (GC_push_all, GC_push_selected): Properly check for empty + region after boundaries alignment (for the case when boundaries + unaligned and the region is short than one word); simplify the checked + condition. + +2012-02-16 Ivan Maidanski + + * finalize.c (GC_finalizer_nested): Change type from char to int to + force GC symbols proper alignment for some compilers (e.g., Watcom); + add comment. + * finalize.c (GC_check_finalizer_nested): Cast GC_finalizer_nested + properly (since it holds an unsigned char value). + * os_dep.c (GC_get_maps): Remove static "init_buf" variable (of char + size) and initialize "maps_buf" to NULL since it is allocated anyway + (since maps_size is non-zero). + * os_dep.c (GC_register_data_segments): Remove static "dummy" variable + (of char size) and use GC_pages_executable instead. + +2012-02-14 Ivan Maidanski + + * include/private/gcconfig.h (NO_DYLD_BIND_FULLY_IMAGE): Do not define + if already defined (e.g., by compiler -D option). + +2012-02-10 Ivan Maidanski + + * mark_rts.c (GC_add_roots_inner): Fix update of GC_root_size value + for Win32 (adjust GC_root_size before altering r_start/r_end). + +2012-02-01 Ivan Maidanski + + * include/gc.h (GC_dont_gc): Improve comment (add note for new client + code). + * include/gc.h (GC_is_disabled): New API function. + * misc.c (GC_is_disabled): Likewise. + +2012-02-01 Ivan Maidanski + + * include/gc.h (GC_stackbottom): Improve comment (add note for + new client code). + +2012-02-01 Ivan Maidanski + + * include/gc.h (GC_base): Fix a typo in the comment. + +2012-02-01 Ivan Maidanski + + * cord/cordtest.c (main): Print "SUCCEEDED" message to stdout + instead of stderr. + +2012-01-31 Ivan Maidanski + + * allchblk.c (GC_add_to_fl): Append ';' after FREE_ASSERT(). + * allchblk.c (GC_remove_from_fl): Fix a typo in a comment. + +2012-01-26 Ivan Maidanski + + * include/private/gcconfig.h (USE_GET_STACKBASE_FOR_MAIN): Define if + PLATFORM_ANDROID. + +2012-01-26 Ivan Maidanski (really Daniel R. Grayson) + + * mark_rts.c (GC_add_roots_inner): Round "b" pointer up to word + boundary. + * include/gc.h (GC_add_roots): Update the comment. + +2012-01-24 Ivan Maidanski + + * pthread_support.c (STAT_READ, STAT_BUF_SIZE): Move the definition + out of PLATFORM_ANDROID condition. + * pthread_support.c (GC_get_nprocs_present): New static function + obtaining number of avalable CPUs from + "/sys/devices/system/cpu/present" (only Linux/arm excluding NaCl). + * pthread_support.c (GC_thr_init): Invoke GC_get_nprocs_present + (unless set from the environment variable) to workaround a bug in + some Linux/arm kernels (including Android). + +2012-01-24 Ivan Maidanski + + * pthread_support.c (GC_get_nprocs): Change "result" local variable + type to int from word (to match returned value type); remove redundant + cast; initialize "result" variable just before its use. + +2012-01-23 Ivan Maidanski + + * os_dep.c (GC_sigbus_count): Fix a typo in a comment. + +2012-01-20 Ivan Maidanski + + * configure.ac (AC_INIT): Update bug reports email. + * doc/gcdescr.html: Likewise. + * doc/README.cords: Likewise. + * doc/overview.html: Fix email address. + +2012-01-18 Ivan Maidanski + + * tests/realloc_test.c (main): Prevent NULL pointer dereference + (exit with an error message in case of NULL returned by GC_malloc). + +2012-01-17 Ivan Maidanski + + * cord/cordtest.c (FNAME1, FNAME2): Do not specify folder + (platform-dependent) for temporary file; use same short file name + (DOS-compatible) for all targets. + +2012-01-13 Ivan Maidanski + + * extra/gc.c: Include gc_pthread_redirects.h (unless + GC_NO_THREAD_REDIRECTS) to restore thread calls macro-based + redirection after the corresponding undef's in pthread_support.c. + * win32_threads.c: Restore thread calls macro-based redirection + (unless GC_NO_THREAD_REDIRECTS) at the file end. + * extra/gc.c: Remove "file not well tested" comment. + +2012-01-10 Ivan Maidanski + + * pthread_stop_world.c (GC_restart_handler): Preserve errno value in + case of sem_post or GC_log_printf invocation inside. + +2011-12-30 Ivan Maidanski + + * Makefile.in: Regenerate. + +2011-12-30 Ivan Maidanski + + * Makefile.am (pkginclude_HEADERS): Remove gc_allocator.h + entry. + * Makefile.am (include_HEADERS): Add include/extra/gc_cpp.h entry + (only if CPLUSPLUS). + * include/include.am (pkginclude_HEADERS): Remove include/gc_cpp.h + entry. + * include/include.am (include_HEADERS): Remove include/extra/gc_cpp.h + entry. + +2011-12-30 Ivan Maidanski + + * misc.c (GC_init): Append ';' after GC_ASSERT(). + * os_dep.c (GC_protect_heap): Likewise. + +2011-12-30 Ivan Maidanski + + * tests/test_cpp.cc (GC_API_PRIV): New macro (same definition as in + gc_priv.h). + * tests/test_cpp.cc (GC_printf): Use GC_API_PRIV instead of GC_API. + +2011-12-30 Ivan Maidanski + + * dyn_load.c (GC_dyld_image_add, GC_dyld_image_remove): Declare i, j + local variables as unsigned (to prevent compiler warning in + a comparison involving sizeof) + +2011-12-27 Ivan Maidanski (really Richard Sandiford) + + * include/private/gcconfig.h (HBLKSIZE): Define for MIPS. + +2011-12-27 Ivan Maidanski (really David Daney) + + * include/private/gcconfig.h (CPP_WORDSZ, ALIGNMENT): Handle + mips64-linux n64 ABI. + +2011-12-15 Ivan Maidanski + + * configure: Regenerate. + +2011-12-15 Ivan Maidanski + + * configure.ac (ac_cv_fno_strict_aliasing): New variable (set to + "skipped" if the client passed "-fstrict-aliasing" option to CFLAGS + else set to "yes" if GCC supports "-fno-strict-aliasing" option, + otherwise set to "no"). + * configure.ac (CFLAGS): Append "-fno-strict-aliasing" if + ac_cv_fno_strict_aliasing is "yes" (only if GCC). + +2011-12-13 Ivan Maidanski + + * configure: Regenerate. + +2011-12-13 Ivan Maidanski + + * configure.ac (ac_is_dgux): Move down to below gc-debug processing + (DG/UX) since it uses "enable_gc_debug" variable; remove FIXME. + +2011-12-13 Ivan Maidanski + + * configure.ac (CFLAGS, CXXFLAGS): Preserve C/C++ flags passed by + client (DG/UX only); remove code duplication (put common flags to + "dgux_spec_opts" variable). + +2011-11-23 Ivan Maidanski (really Bruce Mitchener) + + * README: Fix typos. + * doc/README.cmake: Likewise. + * doc/README.darwin: Likewise. + * autogen.sh: Set file 'executable' bit. + +2011-11-15 Ivan Maidanski + + * pthread_support.c (GC_is_thread_tsd_valid): Check tsd more correctly + using GC_thread and thread_local_freelists declarations; remove FIXME. + * win32_threads.c (GC_is_thread_tsd_valid): Likewise. + +2011-11-15 Ivan Maidanski + + * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Test result of + GC_getspecific() for NULL in all cases except for USE_COMPILER_TLS and + USE_WIN32_COMPILER_TLS (i.e., no-op implementation of GC_getspecific). + +2011-10-10 Ivan Maidanski (really Linas Vepstas) + + * include/private/gcconfig.h: Add machine description for Hexagon. + +2011-09-30 Ivan Maidanski + + * tests/test.c (mktree): Insert CHECK_OUT_OF_MEMORY to report mktree() + out-of-memory failures. + * tests/trace_test.c (mktree): Test whether GC_MALLOC_ATOMIC returns + NULL (exit with an error code and the appropriate message printed in + this case). + +2011-09-23 Ivan Maidanski + + * configure: Regenerate. + +2011-09-23 Ivan Maidanski + + * configure.ac (NO_DEBUGGING): Define based on testing enable_gc_debug + value (instead of based on with_cross_host value). + +2011-09-23 Ivan Maidanski + + * configure.ac (THREAD_LOCAL_ALLOC): Test enable_shared and + enable_static values properly when setting THREAD_LOCAL_ALLOC + in case PARALLEL_MARK is off (Win32 only). + +2011-09-22 Ivan Maidanski + + * configure: Regenerate. + * include/private/config.h.in: Ditto. + +2011-09-22 Ivan Maidanski + + * configure.ac (GC_DLL): New AC template; define if only the dynamic + libraries are being built. + * configure.ac (THREAD_LOCAL_ALLOC): Define for Win32 implicitly + if static libraries are being built (i.e. GC_DLL is not defined). + * doc/README.win32: Update "GNU Tools" section. + +2011-09-22 Ivan Maidanski + + * configure.ac (THREADS): Change "posix" to "win32" in case of + cross-compiling to MinGW. + +2011-09-22 Ivan Maidanski + + * configure.ac (PARALLEL_MARK): Check --enable-parallel-mark also for + Solaris. + +2011-09-20 Ivan Maidanski + + * pthread_start.c (GC_inner_start_routine): Add volatile to "me" local + variable to prevent its clobbering. + +2011-09-20 Ivan Maidanski + + * tests/threadkey_test.c (main): Print a message if the test is + skipped. + +2011-09-14 Ivan Maidanski + + * backgraph.c (per_object_helper): Cast "i" local variable to word + (instead of "sz") in a comparison. + +2011-09-14 Ivan Maidanski + + * Makefile.direct (Makefile): Add rule to create (or overwrite) + Makefile from Makefile.direct file. + * Makefile.direct (clean): Remove "base_lib", "c++" files as well. + +2011-09-13 Ivan Maidanski + + * CMakeLists.txt (CMAKE_LEGACY_CYGWIN_WIN32): Set to 0 (required for + Cygwin). + +2011-09-13 Ivan Maidanski + + * tests/test.c (check_heap_stats): Increase max_heap_sz value (for + 32-bit targets) from 15M by 1M (as the former is hit sometimes on + Cygwin). + +2011-09-13 Ivan Maidanski + + * CMakeLists.txt (cygwin): Remove "-D_REENTRANT" definition. + * CMakeLists.txt (cord): Add gdi32 link library. + +2011-09-13 Ivan Maidanski + + * cord/de.c (WIN32): Define also for Cygwin. + +2011-09-13 Ivan Maidanski + + * gc_cpp.cc (operator delete): Do not define for Cygwin since already + defined in include/gc_cpp.h file. + +2011-09-08 Ivan Maidanski + + * cord/cordprnt.c (CORD_vsprintf): Cast "prec" and "width" local + variables to size_t. + * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr): Change + type of "i" local variable to int. + * pthread_support.c (start_mark_threads): Likewise. + * os_dep.c (GC_repeat_read): Change type of "num_read" to size_t. + * os_dep.c (GC_get_maps): Change type of "result" local variable from + int to ssize_t; cast "result" to size_t in comparison. + * pthread_support.c (GC_remove_all_threads_but_me): Cast "result" to + int. + * pthread_support.c (GC_wait_for_gc_completion): Change type of + "old_gc_no" local variable to word. + * pthread_support.c (GC_lock): Change type of "i" local variable to + unsigned. + * tests/staticrootstest.c (main): Cast sizeof() value to int in + comparisons. + +2011-09-07 Ivan Maidanski + + * os_dep.c (GC_find_limit_with_bound): Inside loop, set result local + volatile variable and do break instead of return (this also suppresses + compiler warning about the potential clobbering of "bound" variable + by setjmp). + +2011-09-07 Ivan Maidanski + + * include/gc.h (GC_get_heap_size, GC_get_free_bytes, + GC_get_unmapped_bytes, GC_get_bytes_since_gc, GC_get_total_bytes): + Refine comment. + * include/gc.h (GC_HAVE_GET_HEAP_USAGE_SAFE): New macro. + * include/gc.h (GC_get_heap_usage_safe): New API function. + * misc.c (GC_get_heap_usage_safe): Likewise. + * include/gc_mark.h (GC_get_heap_size_inner, GC_get_free_bytes_inner): + Remove API function. + * misc.c (GC_get_heap_size_inner, GC_get_free_bytes_inner): Likewise. + * misc.c (GC_get_heap_size): Add comment. + * misc.c (GC_get_heap_size, GC_get_free_bytes, GC_get_unmapped_bytes, + GC_get_bytes_since_gc, GC_get_total_bytes): Remove locking. + * misc.c (GC_get_unmapped_bytes): Do not test USE_MUNMAP (not needed + after locking removal). + * misc.c (GC_get_bytes_since_gc, GC_get_total_bytes): Cast result to + size_t. + +2011-09-06 Ivan Maidanski + + * include/gc_mark.h (GC_set_start_callback): Refine comment (the + function acquires the GC lock). + * include/gc.h (GC_set_all_interior_pointers, GC_set_stop_func, + GC_get_stack_base): Likewise. + * include/gc.h (GC_get_version, GC_get_gc_no, GC_get_parallel, + GC_set_find_leak, GC_get_all_interior_pointers, + GC_get_dont_precollect, GC_get_pages_executable, GC_set_max_heap_size, + GC_set_force_unmap_on_gcollect): Refine comment (the function is + lock-free). + +2011-08-31 Ivan Maidanski + + * tests/initsecondarythread.c: Include windows.h instead of pthread.h + unless GC_PTHREADS. + * tests/thread_leak_test.c: Likewise. + * tests/initsecondarythread.c (thread): Use WINAPI and set return + type to DWORD unless GC_PTHREADS. + * tests/thread_leak_test.c (test): Likewise. + * tests/initsecondarythread.c (main): Use HANDLE, CreateThread and + WaitForSingleObject instead of pthread_t, pthread_create and + pthread_join, respectively, unless GC_PTHREADS. + * tests/thread_leak_test.c (main): Likewise. + +2011-08-31 Ivan Maidanski + + * tests/initsecondarythread.c (GC_NO_THREAD_REDIRECTS): Add comment. + * tests/initsecondarythread.c: Include stdio.h. + * tests/initsecondarythread.c (thread): Cast result of malloc to void; + return arg parameter instead of NULL (to suppress compiler warnings). + * tests/initsecondarythread.c (main): Define "code" local variable; + store result of pthread_create and pthread_join to "code" variable; + exit application with an error code (with the corresponding error + message) if pthread_create or pthread_join fails. + +2011-08-31 Ivan Maidanski (really Jean-Claude Beaudoin) + + * include/private/gcconfig.h (GETCONTEXT_FPU_EXCMASK_BUG): Add FIXME + that this is no longer needed with the recent GLibC. + +2011-08-24 Ivan Maidanski + + * hpux_test_and_clear.s: Remove. + * Makefile.am (EXTRA_DIST): Remove hpux_test_and_clear.s. + * Makefile.direct (SRCS): Ditto. + * Makefile.dj (SRCS): Ditto. + * Makefile.dj (SRCS): Remove missing gcc_support.c, + include/gc_alloc.h, include/gc_local_alloc.h. + * doc/gcdescr.html: Remove information about gc_local_alloc.h. + * doc/gcinterface.html: Ditto. + * doc/scale.html: Ditto. + * doc/gcinterface.html: Remove information about gc_alloc.h. + * tests/test_cpp.cc: Don't include missing old gc_alloc.h (include + new_gc_alloc.h instead); don't test __GNUC__. + * tests/test_cpp.cc (main): Use gc_alloc class instead of alloc (don't + test __GNUC__). + * windows-untested/vc60/gc.dsp (SOURCE): Don't include missing + gc_alloc.h, gc_local_alloc.h. + * windows-untested/vc60/libgc.dsp (SOURCE): Ditto. + * windows-untested/vc70/gc.vcproj (Header Files): Ditto. + * windows-untested/vc70/libgc.vcproj (Header Files): Ditto. + * windows-untested/vc71/gc.vcproj (Header Files): Ditto. + * windows-untested/vc71/libgc.vcproj (Header Files): Ditto. + * Makefile.in: Regenerate. + +2011-08-21 Ivan Maidanski + + * allchblk.c (GC_allochblk_nth): Cast MAX_BLACK_LIST_ALLOC and + HBLKSIZE to signed_word. + * mallocx.c (GC_generic_malloc_many): Cast my_bytes_allocd to word. + * mark.c (GC_do_local_mark): Cast the result of local_top minus + local_mark_stack to word (since is non-negative). + * misc.c (GC_base): Declare sz as unsigned word. + * misc.c (GC_enable_incremental): Cast bytes_written to size_t in + comparison to len. + * obj_map.c (GC_initialize_offsets): Declare 'i' as unsigned. + * os_dep.c (GC_or_pages): Ditto. + * typd_mlc.c (GC_init_explicit_typing): Ditto. + * ptr_chck.c (GC_is_visible): Cast the result of p minus base to word. + * typd_mlc.c (GC_make_descriptor): Cast last_set_bit to word (since + non-negative) when compared to BITMAP_BITS. + +2011-08-14 Ivan Maidanski (really Petter Urkedal) + + * configure.ac: Remove checks for ar and ranlib. + * configure.ac: Replace AC_CHECK_HEADER with PKG_CHECK_MODULES when + checking for libatomic_ops. The macro sets the appropriate flags, so + simplify accordingly. + * Makefile.am, configure.ac: Set ATOMIC_OPS_CFLAGS in configure.ac + instead of conditionally doing it in Makefile.am, to be more + consistent with the pkg-config case. + * configure.ac: Fix a typo and some phrases. + * Makefile.in: Regenerate. + * aclocal.m4: Ditto. + * configure: Ditto. + +2011-08-11 Ivan Maidanski (really Petter Urkedal) + + * configure.ac: Since we no longer bundle libatomic_ops, we must + check for the sub-directory before using it, in case we didn't + find an installed version. + * Makefile.am: Don't include libatomic_ops in the distribution. + * Makefile.in: Regenerate. + * configure: Ditto. + +2011-08-09 Ivan Maidanski (really Jie Liu) + + * configure.ac: Add GC_RTEMS_PTHREADS AH_TEMPLATE and configure + for rtems. + * os_dep.c: Add GC_get_stack_base if GC_RTEMS_PTHREADS for rtems. + * pthread_stop_world.c (GC_stop_init): Add ifdef SA_RESTART. + * pthread_stop_world.c (GC_stop_init): Use sigprocmask for rtems + when defined GC_RTEMS_PTHREADS. + * pthread_support.c: Exclude sys/mman.h for rtems. + * pthread_support.c (GC_thr_init): Set default GC_nprocs (1) for + rtems. + * include/gc_config_macros.h: Define GC_RTEMS_PTHREADS for rtems + pthread and define GC_NO_DLOPEN for rtems. + * include/private/gc_locks.h: Define USE_PTHREAD_LOCKS for rtems. + * include/private/gcconfig.h: Use rtems_get_stack_bottom() + for InitStackBottom; and use SIGUSR1 for SIG_SUSPEND, SIGUSR2 + for SIG_THR_RESTART on rtems. + * include/private/thread_local_alloc.h: Use USE_PTHREAD_SPECIFIC + for rtems. + * tests/test.c (Init): Use exit(0) for rtems instead of return. + * configure: Regenerate. + * include/private/config.h.in: Ditto. + +2011-07-26 Ivan Maidanski + + * tests/realloc_test.c: New file. + * tests/tests.am (TESTS, check_PROGRAMS): Add realloc_test. + * .cvsignore: Add realloc_test. + * configure: Regenerate. + * Makefile.in: Ditto. + +2011-07-14 Ivan Maidanski + + * .cvsignore: Add more auto-generated files. + +2011-07-14 Ivan Maidanski + + * new_hblk.c (GC_build_fl): Adjust "h" local variable cast type + when setting obj_link (to prevent compiler warning); reformat the + comment. + * tests/test.c (reverse_test_inner): Use proper type when touching + "b" and "c" local variables (to prevent compiler warning). + +2011-07-05 Ivan Maidanski + + * misc.c (GC_init): Use HOTTER_THAN (instead of STACK_GROWS_DOWN) + for GC_stackbottom assertion. + * os_dep.c (GC_enclosing_mapping): Define only if IA64 or + INCLUDE_LINUX_THREAD_DESCR; make GC_INNER. + * pthread_support.c (GC_enclosing_mapping): Declare (only if + INCLUDE_LINUX_THREAD_DESCR). + * os_dep.c (GC_get_main_stack_base): Don't call pthread_getattr_np + if REDIRECT_MALLOC as the former is observed to call redirected + malloc (while GC is not initialized yet) on some Linux platforms. + * include/private/gc_priv.h (MAX_HEAP_SECTS): Don't use a smaller + value for SMALL_CONFIG if USE_PROC_FOR_LIBRARIES defined. + +2011-07-05 Ivan Maidanski + + * malloc.c (GC_init_lib_bounds): Call GC_init (to ensure GC is + initialized before doing GC_text_mapping). + * misc.c (GC_init): Add a check for GC_init recursion in case of + malloc is redirected (abort with the corresponding message). + * pthread.c (GC_thr_init): Place GC_add_roots_inner call into + "else" branch to prevent "local variable might be uninitialized" + compiler warning; add comment. + +2011-07-05 Ivan Maidanski + + * dyn_load.c (GC_register_dynamic_libraries): Remove duplicate + call of GC_FirstDLOpenedLinkMap (twice). + * dyn_load.c (GC_register_main_static_data): Add comment. + * cord/cordbscs.c (CORD_riter): Check for empty string passed (do + not call CORD_riter4 if CORD_len() returned zero). + * cord/cordbscs.c (CORD_init_min_len): Replace the K&R-style + function definition with the ANSI C one. + * cord/cordbscs.c: Expand all tabs to spaces; remove + trailing spaces at EOLn. + * tests/threadkey_test.c (on_thread_exit_inner): Check + GC_pthread_create() result. + +2011-07-04 Ivan Maidanski + + * include/private/gcconfig.h (etext): Don't define if unused + (NetBSD). + * include/private/gcconfig.h (GC_data_start, DATASTART): Define + for NetBSD/amd64 if ELF. + * include/private/gcconfig.h (SEARCH_FOR_DATA_START): Don't define + for NetBSD/amd64 if ELF. + +2011-07-04 Ivan Maidanski (mostly really Andy Wingo) + + * configure.ac (GC_THREADS): Refine the comment. + * configure.ac (GC_WIN32_PTHREADS): Add template. + * configure.ac (cygwin, win32): Define GC_WIN32_THREADS instead of + GC_THREADS. + * configure.ac (pthreads): Add mingw target (GC_WIN32_PTHREADS). + * configure: Regenerate. + * include/private/config.h.in: Ditto. + * include/private/gc_locks.h (GC_WIN32_PTHREADS): Remove nested + test for the macro; add comment. + +2011-07-01 Ivan Maidanski + + * win32_threads.c (CHECK_LOOKUP_MY_THREAD): New macro definition. + * win32_threads.c (GC_reset_finalizer_nested, + GC_check_finalizer_nested, GC_unregister_my_thread, + GC_do_blocking_inner, GC_call_with_gc_active, GC_init_parallel): + Insert CHECK_LOOKUP_MY_THREAD before dereferencing thread + descriptor pointer (to instruct a LINT-like tool that it is ok to + dereference the pointer). + * win32_threads.c (GC_get_next_stack): Assert plast_stack_min is + non-NULL if current_min is not ADDR_LIMIT (for a LINT-like tool). + * win32_threads.c (GC_init_parallel): Define and use "me" local + variable. + * cord/cordtest.c (test_basics): Test CORD_substr() result is + non-NULL. + * cord/cordtest.c (test_extras): Test fopen() result is non-NULL. + * cord/cordtest.c (test_basics, test_extras, test_printf, main): + Replace the K&R-style function definition with the ANSI C one. + * cord/cordtest.c: Expand all tabs to spaces; remove + trailing spaces at EOLn. + * include/private/gc_priv.h (ABORT): Define as abort() when + checking the code with a LINT-like tool (Win32 only). + * tests/test.c (FAIL): Ditto. + * tests/test.c (CHECH_GCLIB_VERSION): New macro (to check that the + version of libgc.so used at runtime matches that at compile time). + * tests/test.c (GC_COND_INIT): Use CHECH_GCLIB_VERSION. + * tests/test.c (CHECK_OUT_OF_MEMORY): New macro (to test malloc + result for out of memory). + * tests/test.c (cons, small_cons, small_cons_uncollectable, + gcj_cons, reverse_test_inner, mktree, alloc8bytes, typed_test, + run_one_test): Use CHECK_OUT_OF_MEMORY. + +2011-06-30 Ivan Maidanski + + * dyn_load.c (GC_register_map_entries): Remove "count" local + variable as unused. + * gc_dlopen.c (disable_gc_for_dlopen): Define only if not + USE_PROC_FOR_LIBRARIES. + * malloc.c (calloc): Add parentheses around '&&' operator. + * mark.c (GC_noop_sink): New global variable (instead of a static + local variable inside GC_noop1). + * mark.c (GC_noop1): Use GC_noop_sink variable (to prevent + "variable set but not used" compiler warning). + * include/private/gcconfig.h (USE_PROC_FOR_LIBRARIES): Define only + if undefined yet. + * tests/smash_test.c (main): Don't dereference "p" local variable + if it is NULL. + * tests/staticrootslib.c (main): Ditto. + +2011-06-30 Ivan Maidanski + + * pthread_support.c (GC_segment_is_thread_stack): Replace '&' + operator with '&&' one in conditional expressions. + * specific.c (remove_specific): Dereference "entry" local variable + only if it is non-NULL. + * include/gc.h (GC_NEW): Refine the comment (about the returned + value). + +2011-06-15 Ivan Maidanski + + * include/gc_version.h, configure.ac, doc/README: Change to + version 7.2alpha7. + * configure: Regenerate. + +[7.2alpha6] + +2011-06-14 Ivan Maidanski + + * configure_atomic_ops.sh: Remove. + * Makefile.direct (dist gc.tar): Remove configure_atomic_ops.sh. + * Makefile.am (EXTRA_DIST): Add autogen.sh. + * Makefile.in: Regenerate. + * configure: Ditto. + +2011-06-14 Ivan Maidanski + + * include/gc_version.h, configure.ac, doc/README: Change to + version 7.2alpha6. + * configure: Regenerate. + +2011-05-31 Ivan Maidanski + + * NT_STATIC_THREADS_MAKEFILE (.cpp.obj): Remove duplicate .cpp + filename passed. + * NT_X64_THREADS_MAKEFILE (.cpp.obj): Use lowercase file + extension. + * NT_X64_STATIC_THREADS_MAKEFILE (.cpp.obj): Ditto. + * NT_MAKEFILE (.cpp.obj): Ditto. + +2011-05-31 Ivan Maidanski + + * alloc.c (GC_add_current_malloc_heap, GC_build_back_graph, + GC_traverse_back_graph): Move prototype to gc_priv.h. + * checksums.c (GC_page_was_ever_dirty): Ditto. + * dbg_mlc.c (GC_default_print_heap_obj_proc): Ditto. + * dyn_load.c (GC_parse_map_entry, GC_get_maps, + GC_segment_is_thread_stack, GC_roots_present, GC_is_heap_base, + GC_get_next_stack): Ditto. + * finalize.c (GC_reset_finalizer_nested, + GC_check_finalizer_nested): Ditto. + * gcj_mlc.c (GC_start_debugging, GC_store_debug_info): Ditto. + * malloc.c (GC_extend_size_map, GC_text_mapping): Ditto. + * mark_rts.c (GC_mark_thread_local_free_lists): Ditto. + * misc.c (GC_register_main_static_data, GC_init_win32, + GC_setpagesize, GC_init_linux_data_start, + GC_set_and_save_fault_handler, GC_init_dyld, GC_init_netbsd_elf, + GC_initialize_offsets, GC_bl_init, GC_do_blocking_inner, + GC_bl_init_no_interiors): Ditto. + * os_dep.c (GC_greatest_stack_base_below, GC_push_all_stacks): + Ditto. + * reclaim.c (GC_check_leaked): Ditto. + * win32_threads.c (GC_gww_dirty_init): Ditto. + * darwin_stop_world.c (GC_is_mach_marker, GC_mprotect_stop, + GC_mprotect_resume): Move prototype to darwin_stop_world.h. + * pthread_support.c (GC_FindTopOfStack): Ditto. + * dyn_load.c (GC_cond_add_roots): Merge adjacent definitions. + * mark.c (GC_page_was_ever_dirty): Remove (as already declared). + * mark_rts.c (GC_roots_present): Change return type to void + pointer (to match the prototype); return NULL instead of FALSE. + * mark_rts.c (GC_add_roots_inner): Cast GC_roots_present() result. + * os_dep.c (NEED_PROC_MAPS): Move definition to gcconfig.h. + * os_dep.c (GC_write_fault_handler): Make STATIC. + * os_dep.c (GC_set_write_fault_handler): New function (only if + GC_WIN32_THREADS). + * pthread_start.c (GC_start_rtn_prepare_thread, + GC_thread_exit_proc): Move prototype to pthread_support.h. + * pthread_support.c (GC_nacl_initialize_gc_thread, + GC_nacl_shutdown_gc_thread, GC_unblock_gc_signals): + Ditto. + * pthread_support.c (GC_stop_init): Move prototype to + pthread_stop_world.h. + * thread_local_alloc.c (GC_check_tls_for): Reformat comment. + * win32_threads.c (GC_write_fault_handler): Remove prototype. + * win32_threads.c (GC_register_my_thread_inner): Call + GC_set_write_fault_handler instead of SetUnhandledExceptionFilter + (only if MPROTECT_VDB). + * doc/README.win32: Add information about DMC. + * include/private/gc_priv.h (GC_set_write_fault_handler): New + prototype (only if GC_WIN32_THREADS and MPROTECT_VDB). + +2011-05-31 Ivan Maidanski + + * misc.c (vsnprintf): Redirect to vsprintf() if NO_VSNPRINTF. + +2011-05-31 Ivan Maidanski + + * win32_threads.c (GC_unregister_my_thread): Use KNOWN_FINISHED() + instead of FINISHED macro. + * tests/test.c (check_heap_stats): Round up max_heap_sz value for + Win32 (same as for USE_MMAP). + +2011-05-31 Ivan Maidanski + + * tests/test.c (check_heap_stats): Adjust printf format specifier + for max_heap_sz; cast max_heap_sz accordingly. + +2011-05-30 Ivan Maidanski + + * doc/README.solaris2: Add note. + +2011-05-30 Ivan Maidanski + + * configure.ac (SOLARIS25_PROC_VDB_BUG_FIXED): Don't define for + Solaris/x86 2.10+. + * configure: Regenerate. + +2011-05-23 Ivan Maidanski + + * tests/threadkey_test.c (SKIP_THREADKEY_TEST): Skip the test if + defined; explicitly define for some targets. + +2011-05-23 Ivan Maidanski + + * mark.c (GC_dirty): Add prototype (only if MANUAL_VDB). + * stubborn.c (GC_dirty): Ditto. + * include/private/gcconfig.h (GWW_VDB, MPROTECT_VDB, PCR_VDB, + PROC_VDB): Undefine if MANUAL_VDB. + * include/private/gcconfig.h (DEFAULT_VDB): Don't define if + MANUAL_VDB. + * os_dep.c (async_set_pht_entry_from_index): Define for + MANUAL_VDB. + * os_dep.c (GC_read_dirty): Set GC_dirty_maintained only if + success; if ioctl() failed then just print warning instead of + aborting. + +2011-05-23 Ivan Maidanski + + * include/private/gc_priv.h (GC_ASSERT): Use "%d" (instead of %ld) + for line number printing. + +2011-05-23 Ivan Maidanski + + * os_dep.c (GC_read_dirty): Add debug logging if DEBUG_DIRTY_BITS + (for PROC_VDB only); print errors via GC_err_printf; rename "ps" + and "np" local variables to npages and pagesize, respectively; + remove "current_addr" local variable. + * os_dep.c: Reformat comments. + +2011-05-22 Ivan Maidanski + + * os_dep.c (GC_get_main_stack_base): Convert to GC_get_stack_base + for BeOS and OS/2; define HAVE_GET_STACK_BASE. + * os_dep.c (GET_MAIN_STACKBASE_SPECIAL): Define when a specific + GC_get_main_stack_base implementation is defined. + * os_dep.c (GC_get_main_stack_base): Define that based on + GC_get_stack_base() in a single place (only if + GET_MAIN_STACKBASE_SPECIAL is unset); check GC_get_stack_base() + result. + +2011-05-20 Ivan Maidanski + + * mark.c (GC_push_selected): Remove "push_fn" argument (use + GC_push_all directly); update the documentation; reformat the + comment. + * mark.c (GC_push_conditional): Simplify the code (for better + readability). + +2011-05-20 Ivan Maidanski + + * mark.c (alloc_mark_stack): Use FALSE/TRUE (instead of 0/1) for + boolean local variables. + * doc/README.macros (GC_PREFER_MPROTECT_VDB): Update. + * os_dep.c (GC_page_was_dirty, GC_page_was_ever_dirty, + GC_remove_protection): Define for GWW_VDB and PROC_VDB in a single + place. + * os_dep.c (GC_page_was_dirty, GC_page_was_ever_dirty): Compute + PHT_HASH(h) only once (store result to a local variable). + +2011-05-20 Ivan Maidanski + + * doc/README.solaris2: Update. + +2011-05-19 Ivan Maidanski (really Jie Liu) + + * include/private/gcconfig.h (end, InitStackBottom): Declare + extern variable for RTEMS. + * include/private/gcconfig.h (DATASTART, DATAEND, STACKBOTTOM): + Update (for RTEMS). + * include/private/gcconfig.h (DATAEND): Fix a typo in the macro + name (for RTEMS). + * tests/test.c (CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER): + Replace with CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER (for RTEMS). + +2011-05-18 Ivan Maidanski + + * include/private/gcconfig.h (MPROTECT_VDB): Enable for Solaris in + single-threaded environment. + +2011-05-18 Ivan Maidanski + + * include/private/gcconfig.h (MPROTECT_VDB): Undefine if PROC_VDB. + * tests/test.c (NUMBER_ROUND_UP): New macro. + * tests/test.c (check_heap_stats): Round up total expected heap + size to the nearest 4 MiB bound. + * tests/test.c (check_heap_stats): Print the current and expected + heap sizes in case of failure. + +2011-05-18 Ivan Maidanski + + * checksums.c (GC_check_blocks, GC_check_dirty): Do log printing + only if GC_print_stats; print errors using GC_err_printf. + * checksums.c (GC_check_blocks): Join adjacent printf() calls into + a single one. + +2011-05-17 Ivan Maidanski + + * pthread_support.c (pthread_join): Add assertion (check thread is + finished). + * pthread_support.c (GC_register_my_thread): Don't detach the + thread if invoked from the thread destructor. + * win32_threads.c (GC_register_my_thread): Ditto. + * win32_threads.c (GC_unregister_my_thread): Don't delete the + thread (just set FINISHED) if the thread is not detached (only if + GC_PTHREADS); add assertion (check the thread is not finished). + * tests/threadkey_test.c (main): Join some created threads. + +2011-05-17 Ivan Maidanski + + * pthread_support.c (GC_delete_gc_thread): Rename "gc_id" local + variable to "t". + * win32_threads.c (GC_delete_gc_thread): Ditto. + * pthread_support.c (pthread_join, pthread_detach, + pthread_cancel): Rename "thread_gc_id" local variable to "t". + * win32_threads.c (GC_pthread_detach): Ditto. + * win32_threads.c (GC_delete_gc_thread): Remove "gc_nvid" local + variable. + * win32_threads.c (GC_pthread_join): Rename "joinee" local + variable to "t". + +2011-05-16 Ivan Maidanski + + * pthread_stop_world.c (pthread_sigmask): Undefine even if not + DEBUG_THREADS. + * pthread_stop_world.c (GC_unblock_gc_signals): New function (only + if GC_EXPLICIT_SIGNALS_UNBLOCK). + * pthread_support.c (GC_unblock_gc_signals): New prototype. + * pthread_support.c (GC_register_my_thread_inner, + GC_register_my_thread): Call GC_unblock_gc_signals (only if + GC_EXPLICIT_SIGNALS_UNBLOCK); add comment. + * include/private/gcconfig.h (GC_EXPLICIT_SIGNALS_UNBLOCK): New + macro. + +2011-05-16 Ivan Maidanski + + * pthread_stop_world.c (GC_suspend_handler_inner): Remove "dummy", + "sig" local variables; rename my_thread local variable to "self". + +2011-05-13 Ivan Maidanski + + * tests/threadkey_test.c (LIMIT): Use smaller value (don't create + more than 30 in parallel by default). + +2011-05-13 Ivan Maidanski + + * tests/threadkey_test.c (key_once, main): Work around for Solaris + PTHREAD_ONCE_INIT. + * tests/threadkey_test.c (LIMIT): Use smaller value for Solaris. + +2011-05-13 Ivan Maidanski + + * dyn_load.c (GC_FirstDLOpenedLinkMap): Remove unused "r" local + variable. + * pthread_support.c (GC_unregister_my_thread_inner): Revert back + GC_remove_specific invocation; add a comment. + * include/private/thread_local_alloc.h (GC_remove_specific): + Revert back. + * specific.c: Expand all tabs to spaces. + * specific.c (slow_getspecific): Cast qtid to AO_t. + * include/private/specific.h (quick_thread_id): Reformat comment. + * include/private/specific.h (key_create, setspecific, + remove_specific): Remove "extern" keyword. + * include/private/specific.h (getspecific): Change type of "qtid" + local variable to unsigned long. + +2011-05-11 Ivan Maidanski + + * pthread_support.c (GC_check_tls): Fix "#endif" comment. + * include/gc.h (GC_REDIRECT_TO_LOCAL): Remove deprecated comment. + * include/private/thread_local_alloc.h (THREAD_LOCAL_ALLOC): + Remove redundant test of the macro. + * include/private/thread_local_alloc.h: Reformat the code. + +2011-05-11 Ivan Maidanski + + * backgraph.c (add_edge): Recognize DEBUG_PRINT_BIG_N_EDGES macro. + * os_dep.c (GC_set_and_save_fault_handler): Recognize + SIGACTION_FLAGS_NODEFER_HACK macro. + * pthread_support.c (mark_mutex): Recognize GLIBC_2_1_MUTEX_HACK + macro. + * pthread_support.c (GC_acquire_mark_lock): Remove commented out + code. + * include/gc_inline.h (GC_MALLOC_WORDS, GC_MALLOC_ATOMIC_WORDS, + GC_CONS): Remove trailing space (before back-slash). + * include/private/gc_hdrs.h (GET_BI, GET_HDR_ADDR): Ditto. + * include/private/gc_pmark.h (PUSH_OBJ, PUSH_CONTENTS, + SET_MARK_BIT_EXIT_IF_SET, LONG_MULT, PUSH_CONTENTS_HDR, + GC_PUSH_ONE_STACK, GC_PUSH_ONE_HEAP): Ditto. + * include/private/thread_local_alloc.h (GC_key_create): Ditto. + * include/private/gc_priv.h (SUNOS5SIGS): Don't include + sys/siginfo.h on Linux. + * include/private/gcconfig.h: Reformat comments (and some code). + * include/private/gcconfig.h (FORCE_WRITE_PREFETCH): New macro + recognized, force PREFETCH_FOR_WRITE to be defined on x86. + * include/private/gcconfig.h (USE_HPUX_FIXED_STACKBOTTOM): New + macro recognized (for HP/UX). + +2011-05-11 Ivan Maidanski + + * os_dep.c (GC_gww_page_was_ever_dirty): Fix comment (for + GWW_VDB). + * os_dep.c (GC_dirty_init): Use memset() for GC_written_pages + resetting (for PROC_VDB). + +2011-05-11 Ivan Maidanski (mostly really Ludovic Courtes) + + * tests/threadkey_test.c: New file. + * .cvsignore (threadkey_test): Add. + * tests/tests.am (TESTS, check_PROGRAMS): Add 'threadkey_test'. + * tests/tests.am (threadkey_test_SOURCES, threadkey_test_LDADD): + New variable. + * Makefile.in: Regenerate. + +2011-05-11 Ivan Maidanski + + * pthread_support.c (GC_unregister_my_thread_inner): Don't call + GC_remove_specific. + * include/private/thread_local_alloc.h (GC_remove_specific): + Remove (since it is empty for all targets). + * pthread_support.c (GC_record_stack_base): New inline function. + * win32_threads.c (GC_record_stack_base): Ditto. + * pthread_support.c (GC_register_my_thread_inner): Invoke + GC_record_stack_base. + * win32_threads.c (GC_register_my_thread_inner): Ditto. + * pthread_support.c (GC_register_my_thread): If thread is FINISHED + then call GC_record_stack_base, clear FINISHED, initialize + thread-local list and return success. + * win32_threads.c (GC_register_my_thread): Ditto. + * include/gc.h (GC_register_my_thread): Update documentation. + * include/private/thread_local_alloc.h (GC_thread_key): Ditto. + +2011-05-10 Ivan Maidanski + + * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Join + adjacent "#ifdef". + * thread_local_alloc.c (GC_malloc_atomic): Call + GC_core_malloc_atomic (instead of GC_core_malloc). + +2011-05-10 Ivan Maidanski + + * pthread_start.c (GC_start_rtn_prepare_thread): Change return + type to GC_thread. + * pthread_start.c (GC_inner_start_routine): Pass the current + thread descriptor to pthread_cleanup_push (same as in + win32_threads.c). + * pthread_stop_world.c (GC_push_all_stacks): Rename "me" local + variable to "self". + * win32_threads.c (GC_push_all_stacks): Ditto. + * pthread_stop_world.c (GC_suspend_all, GC_start_world): Rename + "my_thread" local variable to "self". + * pthread_support.c (GC_unregister_my_thread_inner): New static + function. + * pthread_support.c (GC_unregister_my_thread, + GC_thread_exit_proc): Use GC_unregister_my_thread_inner. + * win32_threads.c (GC_register_my_thread, GC_unregister_my_thread, + GC_do_blocking_inner): Rename "t" local variable to "thread_id". + * win32_threads.c (GC_wait_marker, GC_notify_all_marker): Rename + "id" local variable to "thread_id". + +2011-05-10 Ivan Maidanski + + * pthread_support.c (GC_unregister_my_thread): Call pthread_self + only once. + * win32_threads.c (GC_pthread_start_inner): Ditto. + * pthread_support.c (GC_unregister_my_thread): Add debug output. + * win32_threads.c (GC_unregister_my_thread): Ditto. + * pthread_support.c (GC_register_my_thread, + GC_start_rtn_prepare_thread): Rename "my_pthread" local variable + to "self". + +2011-05-10 Ivan Maidanski + + * include/gc.h (GC_HIDE_POINTER, GC_REVEAL_POINTER): Define + unconditionally (do not test GC_I_HIDE_POINTERS); update the + comment. + * include/gc.h (HIDE_POINTER, REVEAL_POINTER): Define as alias to + GC_HIDE/REVEAL_POINTER, respectively. + * include/private/gc_pmark.h (GC_I_HIDE_POINTERS): Do not define. + * include/private/gc_priv.h (GC_I_HIDE_POINTERS): Ditto. + +2011-05-10 Ivan Maidanski + + * include/gc.h (GC_register_my_thread): Refine the comment. + +2011-05-08 Ivan Maidanski + + * include/gc_inline.h (GC_MALLOC_WORDS, GC_CONS): Add missing + parentheses. + * include/gc_typed.h (GC_get_bit, GC_set_bit, + GC_CALLOC_EXPLICITLY_TYPED): Ditto. + +2011-05-07 Ivan Maidanski + + * include/private/gcconfig.h (NO_GETCONTEXT): Add missing ')'. + +2011-05-07 Ivan Maidanski (really Thorsten Glaser) + + * include/private/gcconfig.h (NO_GETCONTEXT): Do not use + getcontext(2) on m68k because it is not implemented there. + +2011-05-07 Ivan Maidanski + + * alloc.c (GC_clear_a_few_frames): Use BZERO(). + * mark_rts.c (GC_clear_roots, GC_rebuild_root_index): Ditto. + * reclaim.c (GC_start_reclaim): Ditto. + * blacklst.c (total_stack_black_listed): Remove "len" local + variable. + * dbg_mlc.c (GC_generate_random_valid_address): Replace "for" + statement with "do-while" one. + * dyn_load.c (GC_register_dynamic_libraries, + GC_register_dynlib_callback): Remove redundant parentheses. + +2011-05-06 Ivan Maidanski + + * cord/cordxtra.c (CORD_from_file_lazy_inner): Suppress + "unused result" compiler warning for fread(). + * cord/cordxtra.c: Expand all tabs to spaces. + +2011-05-06 Ivan Maidanski + + * os_dep.c (GC_write_fault_handler): Break when in_allocd_block + is set to true. + +2011-05-06 Ivan Maidanski + + * dbg_mlc.c (GC_has_other_debug_info): Change return type to int; + return -1 if the object has (or had) debugging info but was + marked deallocated. + * include/private/dbg_mlc.h (GC_has_other_debug_info): Ditto. + * dbg_mlc.c (GC_has_other_debug_info): Update documentation; + remove "ohdr" local variable. + * dbg_mlc.c (GC_debug_free): Don't call GC_free if the object has + probably been deallocated. + * dbg_mlc.c (GC_debug_free): Don't actually free the object even + in the leak-finding mode if GC_findleak_delay_free. + * dbg_mlc.c (GC_print_all_smashed_proc): Print a trailing blank + line. + * dbg_mlc.c (GC_check_leaked): New function (only unless + SHORT_DBG_HDRS). + * doc/README.environment (GC_FINDLEAK_DELAY_FREE): Document. + * doc/README.macros (GC_FINDLEAK_DELAY_FREE): Ditto. + * include/private/dbg_mlc.h (START_FLAG, END_FLAG): Use GC_WORD_C + on 64-bit architectures. + * include/private/dbg_mlc.h (NOT_MARKED): Remove redundant + parentheses. + * include/private/dbg_mlc.h (GC_HAS_DEBUG_INFO): Update (due to + GC_has_other_debug_info change). + * include/private/gc_priv.h (GC_findleak_delay_free): New global + variable declaration (unless SHORT_DBG_HDRS). + * misc.c (GC_findleak_delay_free): New global variable; recognize + GC_FINDLEAK_DELAY_FREE. + * misc.c (GC_init): Recognize GC_FINDLEAK_DELAY_FREE environment + variable (unless SHORT_DBG_HDRS). + * reclaim.c (GC_check_leaked): Declare (unless SHORT_DBG_HDRS). + * reclaim.c (GC_add_leaked): Don't add the object to leaked list + if marked as deallocated. + +2011-05-05 Ivan Maidanski + + * dbg_mlc.c (GC_has_other_debug_info): Fix punctuation in the + comment. + * dbg_mlc.c (GC_FREED_MEM_MARKER): New macro. + * dbg_mlc.c (GC_debug_free): Use GC_FREED_MEM_MARKER. + * dbg_mlc.c (GC_smashed): Refine documentation. + * mark.c (GC_push_selected): Change dirty_fn return type to + GC_bool. + * os_dep.c (GC_page_was_ever_dirty): Make GC_INNER. + * reclaim.c (GC_reclaim_small_nonempty_block): Remove "kind" + local variable. + * reclaim.c (GC_reclaim_block): Pass true constant to + GC_reclaim_small_nonempty_block (instead of report_if_found). + * doc/README.autoconf: Update; fix a typo. + * include/private/gcconfig.h (GC_WORD_C): New macro. + +2011-05-03 Ivan Maidanski + + * dbg_mlc.c (GC_store_debug_info_inner): Cast "linenum". + * dbg_mlc.c (GC_check_annotated_obj): Fix punctuation in the + comment. + * dbg_mlc.c (GC_print_smashed_obj): Add (and print) "msg" + argument. + * dbg_mlc.c (GC_debug_free, GC_print_all_smashed_proc): Pass + message to GC_print_smashed_obj. + * dbg_mlc.c (GC_debug_free): Call GC_size once. + * dbg_mlc.c (GC_debug_realloc): Calculate old_sz only if + allocation succeeded; remove unnecessary check for object is + smashed (since this is done in GC_debug_free); remove "clobbered" + local variable. + +2011-05-03 Ivan Maidanski + + * dbg_mlc.c (GC_store_debug_info_inner, GC_store_debug_info): + Rename "integer" argument to "linenum"; change the type of the + argument to int. + * gcj_mlc.c (GC_store_debug_info): Ditto. + * dbg_mlc.c (GET_OH_LINENUM): New macro. + * dbg_mlc.c (GC_print_obj, GC_print_smashed_obj): Use + GET_OH_LINENUM; adjust print format specifier. + * dbg_mlc.c (GC_debug_malloc, GC_debug_malloc_ignore_off_page, + GC_debug_malloc_atomic_ignore_off_page, + GC_debug_generic_malloc_inner, + GC_debug_generic_malloc_inner_ignore_off_page, + GC_debug_malloc_stubborn, GC_debug_malloc_atomic, + GC_debug_malloc_uncollectable, + GC_debug_malloc_atomic_uncollectable): Remove unnecessary cast of + "i". + * gcj_mlc.c (GC_debug_gcj_malloc): Ditto. + +2011-04-26 Ivan Maidanski + + * .cvsignore (initsecondarythread, test_cpp): Add. + * os_dep.c (GC_linux_stack_base): Rename to + GC_linux_main_stack_base. + * os_dep.c (GC_freebsd_stack_base): Rename to + GC_freebsd_main_stack_base; adjust error message. + * pthread_stop_world.c (GC_stop_init): Use GC_SEM_INIT_PSHARED + as an argument for sem_init(). + * pthread_support.c (pthread_create): Ditto. + * pthread_support.c (pthread_create): Abort in case sem_init() + fails. + * include/private/gc_priv.h (GC_SEM_INIT_PSHARED): Define. + * tests/initsecondarythread.c: Include gcconfig.h; call GC_INIT + from main() if it should be done from the primordial thread only. + +2011-04-26 Ivan Maidanski + + * alloc.c: Don't include sys/types.h for ArmCC. + * dyn_load.c: Ditto. + * os_dep.c: Ditto. + * mach_dep.c (_setjmp, _longjmp): Redirect to setjmp/longjmp for + ArmCC. + * mark.c (GC_noop): Define specially for ArmCC. + * include/private/gc_priv.h (GC_noop): Ditto. + * misc.c (GC_init): Don't test pointers comparison for ArmCC. + * misc.c: Don't include unistd.h for ArmCC. + * os_dep.c (pages_executable): Rename to GC_pages_executable; + make STATIC. + * os_dep.c (GC_unix_mmap_get_mem): Don't define for ArmCC. + * ptr_chck.c (GC_is_visible): Explicitly cast + (GC_DS_PER_OBJECT-GC_INDIR_PER_OBJ_BIAS) to word (to suppress + a compiler warning). + * include/private/gcconfig.h: Recognize __arm. + * include/private/gcconfig.h (HBLKPTR): Define for ArmCC. + * include/private/gcconfig.h (HBLKPTR): Add parentheses for + "bytes" argument. + +2011-04-24 Ivan Maidanski + + * pthread_support.c (GC_get_nprocs): Don't define for Android. + * pthread_support.c (GC_dummy_thread_local): Don't test + GC_LINUX_THREADS. + * include/gc_config_macros.h (GC_ADD_CALLER, GC_RETURN_ADDR): + Define for Android. + +2011-04-24 Ivan Maidanski + + * mach_dep.c (NO_GETCONTEXT): Move to gcconfig.h. + * os_dep.c (GC_write_fault_handler): Don't include ucontext.h if + NO_GETCONTEXT. + * include/private/gcconfig.h (GETPAGESIZE): Define as a sysconf + call for Android. + +2011-04-23 Ivan Maidanski + + * include/private/gc_locks.h (WIN32_LEAN_AND_MEAN, NOSERVICE): + Define before including windows.h. + * include/private/gc_priv.h (WIN32_LEAN_AND_MEAN, NOSERVICE): + Ditto. + * include/private/thread_local_alloc.h (WIN32_LEAN_AND_MEAN, + NOSERVICE): Ditto. + * include/private/gc_priv.h (CLOCKS_PER_SEC): Reformat the + comment. + * include/private/gc_priv.h (MS_TIME_DIFF): Avoid floating-point + arithmetics; add a comment. + +2011-04-23 Ivan Maidanski + + * mark.c (GC_clear_hdr_marks): Don't test USE_MARK_BYTES. + * extra/setjmp_t.c (main): Don't test USE_MARK_BITS. + * include/private/gc_pmark.h (SET_MARK_BIT_EXIT_IF_SET): Ditto. + * include/private/gc_pmark.h (SET_MARK_BIT_EXIT_IF_SET): Remove + "mark_byte" local variable. + * include/private/gc_pmark.h (OR_WORD_EXIT_IF_SET): Add a comment + about that AO_or() is not used by GC unless USE_MARK_BITS + explicitly set. + * include/private/gc_priv.h (OR_WORD): Ditto. + * include/private/gc_pmark.h (INCR_MARKS): Remove trailing ';', + add parentheses. + * include/private/gc_priv.h (ONES): Define before use by + MAKE_COOLER. + * include/private/gc_priv.h (MARK_BITS_SZ): Define where used. + * include/private/gc_priv.h (OR_WORD): Don't define if + USE_MARK_BYTES. + * include/private/gcconfig.h (USE_MARK_BYTES); Remove duplicate + definition; simplify expression. + +2011-04-22 Ivan Maidanski + + * os_dep.c (GC_get_maps): Always close the file. + * pthread_support.c (GC_get_nprocs): Ditto. + * os_dep.c (READ): Define similarly across the file (without + parameters). + * pthread_support.c (GC_get_nprocs): Use signed int type for "i" + and "len" local variables (since read() may return -1). + * include/private/gc_pmark.h (LONG_MULT): Add prefix/suffix + double underscore; add "volatile" for asm. + * include/private/gc_pmark.h (LONG_MULT): Add missing + parentheses. + * include/private/gc_priv.h (OR_WORD): Ditto. + * include/private/gc_priv.h (OR_WORD): Remove unnecessary brackets + and ';' symbol. + +2011-04-22 Ivan Maidanski + + * os_dep.c (GC_get_stack_base): Implement for Android (same as + for Linux). + * pthread_support.c (GC_get_nprocs): Return 1 (instead of -1) if + failed to open "stat" file (not to issue a warning twice); update + the comment. + * pthread_support.c (GC_thr_init): Call sysconf() on Android to + get the number of CPUs. + +2011-04-21 Ivan Maidanski + + * include/private/gc_priv.h (_GNU_SOURCE): Revert one of the + recent patches regarding this macro as the macro should be set + (to 1) before including any other system header. + +2011-04-21 Ivan Maidanski + + * doc/README.environment (GC_INITIAL_HEAP_SIZE, + GC_MAXIMUM_HEAP_SIZE): Update. + +2011-04-20 Ivan Maidanski + + * misc.c (GC_parse_mem_size_arg): Allow 'k', 'M', 'G' suffixes in + heap size specifier; return 0 if not a valid one. + * include/gc_cpp.h: Explicitly define inline one-argument delete + operator for Cygwin (as a workaround). + * include/gc_cpp.h: Reformat the code. + * tests/test_cpp.cc: Ditto. + * tests/test_cpp.cc (main): Suppress compiler warnings about + "assigned value is unused". + +2011-04-19 Ivan Maidanski + + * misc.c (GC_parse_mem_size_arg): New function. + * misc.c (GC_init): Use GC_parse_mem_size_arg(). + * pthread_stop_world.c (tkill): Declare for Android. + +2011-04-19 Ivan Maidanski + + * include/private/gc_priv.h (_GNU_SOURCE): Include features.h + first (except for NaCl) and then define the macro to 1 if not yet. + +2011-04-18 Ivan Maidanski (really Ludovic Courtes) + + * tests/tests.am (TESTS, check_PROGRAMS): Add + 'initsecondarythread'. + * tests/tests.am (initsecondarythread_SOURCES, + initsecondarythread_LDADD): New variable. + * Makefile.in: Regenerate. + * configure: Ditto. + +2011-04-18 Ivan Maidanski + + * dbg_mlc.c (GC_store_debug_info_inner): Always define; add + "const" to its string argument. + * dbg_mlc.c (GC_store_debug_info): Call GC_store_debug_info_inner. + * dbg_mlc.c (GC_debug_free): Set GC_have_errors in case of + smashed or previously deallocated found. + * dbg_mlc.c (GC_check_heap_block): Replace while loop with a for + one. + * reclaim.c (GC_reclaim_check): Ditto. + * dbg_mlc.c (GC_check_heap_proc): Remove redundant cast to word. + * os_dep.c (GC_get_stack_base): Don't initialize + stackbase_main_self/ss_sp on Solaris if thr_main() is zero (thus + calling GC_INIT() from a non-primordial thread is possible now). + * reclaim.c (GC_add_leaked): Turn into an inline one. + * reclaim.c (GC_reclaim_small_nonempty_block): + Change report_if_found type from int/word to boolean. + * include/private/gc_priv.h (GC_start_reclaim): Ditto. + * include/private/gc_priv.h (set_mark_bit_from_hdr, + clear_mark_bit_from_hdr): Place closing parenthesis properly; + reformat the code. + +2011-04-16 Ivan Maidanski + + * os_dep.c (GC_get_main_stack_base): Try to use + pthread_attr_getstack first for Linux if THREADS. + * doc/README.macros (USE_GET_STACKBASE_FOR_MAIN): Adjust text + alignment. + +2011-04-13 Ivan Maidanski + + * dbg_mlc.c (GC_generate_random_backtrace_no_gc): Fix a message + typo. + * dbg_mlc.c (GC_debug_malloc): Add a comment (about zero size). + * dbg_mlc.c (GC_debug_generic_malloc_inner): Reformat the comment. + * dbg_mlc.c (GC_strdup): Call GC_err_printf instead of WARN (in + case of NULL argument). + * dbg_mlc.c (GC_free): In case of NULL argument, just return + (without any warning printed); eliminate "uncollectable" local + variable. + +2011-04-13 Ivan Maidanski (mostly really Rainer Orth) + + * configure.ac (THREADDLLIBS): Use alternate thread library on + Solaris 8. + * configure.ac (need_atomic_ops_asm): Set to true only for Sparc + Solaris. + * configure.ac: Don't use libdl on mips-sgi-irix6. + * configure: Regenerate. + +2011-04-11 Ivan Maidanski (really Jie Liu) + + * mach_dep.c (NO_GETCONTEXT); Define for RTEMS. + * mach_dep.c (GC_with_callee_saves_pushed): Don't call + __builtin_unwind_init() for RTEMS; use setjmp() without the + leading underscore (for RTEMS). + * tests/test.c (BIG): Use smaller value for RTEMS. + * tests/test.c (main): Customize for RTEMS. + +2011-04-11 Ivan Maidanski (mostly really Jim Meyering) + + * configure.host: Remove doubled words in comments. + * os_dep.c: Ditto. + * doc/README: Ditto. + * extra/setjmp_t.c: Ditto. + * tests/huge_test.c: Ditto. + * extra/setjmp_t.c (getpagesize, nested_sp, main, g): Replace the + K&R-style function definition with the ANSI C one. + * extra/setjmp_t.c: Expand all tabs to spaces. + * extra/setjmp_t.c (nested_sp): Implement in the same way as + GC_approx_sp. + +2011-04-10 Ivan Maidanski (really Iain Sandoe, Mike Stump) + + * dyn_load.c (GC_dyld_sections): Add more sctions. + * dyn_load.c (GC_dyld_add_sect_fmts): New static varaible. + * dyn_load.c (L2_MAX_OFILE_ALIGNMENT): New macro. + * dyn_load.c (GC_dyld_image_add, GC_dyld_image_remove): Improve + logging; add support for on-demand sections. + * dyn_load.c (GC_dyld_image_add, GC_dyld_image_remove): Reformat + the code. + +2011-04-10 Ivan Maidanski + + * gcj_mlc.c (GC_gcj_malloc_initialized): Use STATIC unless + GC_ASSERTIONS. + * include/private/gc_priv.h (GC_gcj_malloc_initialized): Don't + declare (as external) unless GC_ASSERTIONS. + * os_dep.c (GC_win32_free_heap): Clear GC_heap_bases[] also for + Cygwin; add FIXME. + * include/private/gcconfig.h: Include for RTEMS. + * include/private/gcconfig.h: Add "#error" for every "-->" mark. + * include/private/gcconfig.h (CLEAR_DOUBLE): Turn the code into + an expression. + * include/private/pthread_support.h (SUSPENDED_EXT): Add new flag + (which existed previously as SUSPENDED and still exists in GCJ). + * include/private/pthread_support.h (DISABLED_GC): Change the + value (as it is already used by SUSPENDED_EXT). + +2011-04-10 Ivan Maidanski (mostly really Iain Sandoe) + + * tests/test.c (reverse_test): Modify count (BIG) for + ppc64-darwin. + +2011-04-09 Ivan Maidanski + + * reclaim.c (GC_print_all_errors): Recognize new GC_ABORT_ON_LEAK + macro and environment variable; abort if any error has been + printed provided the environment variable (or macro) is set. + * doc/README.environment (GC_ABORT_ON_LEAK): Document. + * doc/README.macros (GC_ABORT_ON_LEAK): Ditto. + * doc/README.macros (FIND_LEAK, SUNOS5SIGS, PCR, + USE_COMPILER_TLS): Reformat the text. + +2011-04-09 Ivan Maidanski (really Jie Liu) + + * os_dep.c (GC_unix_sbrk_get_mem, GC_unix_get_mem): Don't define + for RTEMS. + * include/private/gcconfig.h (RTEMS): Add support for. + * include/private/gcconfig.h (GET_MEM): Use calloc() for RTEMS. + +2011-04-09 Ivan Maidanski + + * mallocx.c (GC_malloc_uncollectable): Move to malloc.c (since + it is used internally in some places). + +2011-04-09 Ivan Maidanski + + * dbg_mlc.c (GC_register_finalizer_no_order): Remove redundant + declaration. + * dbg_mlc.c (GC_debug_malloc_replacement, + GC_debug_realloc_replacement): Rename RA to GC_DBG_RA. + * malloc.c (GC_debug_malloc_replacement): Ditto. + * mallocx.c (GC_debug_realloc_replacement): Ditto. + * dbg_mlc.c (GC_store_debug_info): Move proto from dbg_mlc.h. + * malloc.c (GC_strdup, GC_strndup, GC_wcsdup): Move to mallocx.c. + * malloc.c: Include errno.h only REDIRECT_MALLOC; remove redundant + includes of string.h. + * mallocx.c: Include string.h (for GC_strdup). + * include/private/dbg_mlc.h (GC_store_debug_info): Move declaration + to dbg_mlc.c. + * include/private/gc_locks.h (UNCOND_LOCK, UNCOND_UNLOCK): Remove + redundant trailing ';'. + * include/private/gc_priv.h (START_WORLD, COND_DUMP): Ditto. + * include/private/gc_locks.h (LOCK, UNLOCK): Place opening '{' + properly. + * include/private/gc_priv.h (GC_DBG_RA): Move from dbg_mlc.c, + malloc.c, mallocx.c. + +2011-04-07 Ivan Maidanski + + * alloc.c (GC_check_heap, GC_print_all_smashed): Move the + definition from misc.c. + * dbg_mlc.c (GC_debug_malloc_atomic_uncollectable): Define as + public. + * include/gc.h (GC_debug_malloc_atomic_uncollectable): Declare. + * include/gc.h (GC_MALLOC_ATOMIC_UNCOLLECTABLE): Define new public + macro. + * dbg_mlc.c (MAX_SMASHED): Don't define if already set. + * reclaim.c (MAX_LEAKED): Ditto. + * dbg_mlc.c (GC_add_smashed): Add FIXME about the concurrent + access to the global array. + * reclaim.c (GC_add_leaked): Ditto. + * misc.c (GC_print_back_height): Set on if GC_PRINT_BACK_HEIGHT + (new macro) is defined. + * doc/README.macros (GC_PRINT_BACK_HEIGHT): Document. + * misc.c (GC_dump_regularly, GC_init): Replace 0/1 for + GC_dump_regularly and GC_print_back_height variables with + FALSE/TRUE. + * reclaim.c (GC_print_all_errors): Refine the comment. + +2011-04-04 Ivan Maidanski + + * tests/test.c (reverse_test_inner): Undo one of the previous + patches which shifts "c" and "d" pointers only if + ALL_INTERIOR_POINTERS (since interior pointers are always + recognized in stacks). + +2011-04-03 Ivan Maidanski + + * misc.c (GC_stdout, GC_stderr): Move the definition to the place + where GC_log is defined (Unix only). + * misc.c (GC_init): Recognize "GC_ONLY_LOG_TO_FILE" environment + variable and the similar macro; redirect GC_stdout and GC_stderr + to GC_log if "GC_LOG_FILE" environment variable is set unless + prohibited by GC_ONLY_LOG_TO_FILE (Unix only). + * doc/README.environment (GC_ONLY_LOG_TO_FILE): Document. + * doc/README.macros (GC_ONLY_LOG_TO_FILE): Ditto. + +2011-04-03 Ivan Maidanski + + * misc.c (GC_stdout, GC_write): Rename GC_stdout to GC_log (Win32 + only). + * misc.c (GC_write): Add for MacOS (and OS/2); change WRITE() + accordingly. + * misc.c (GC_write): Reformat code (Unix only). + * misc.c (GC_printf): Check GC_quiet before va_start(). + +2011-04-03 Ivan Maidanski + + * allchblk.c (GC_freehblk): Use GC_log_printf instead of GC_printf + inside "if (GC_print_stats)" branch. + * alloc.c (GC_collect_or_expand): Ditto. + * dyn_load.c (GC_register_dynamic_libraries): Ditto. + * headers.c (GC_scratch_alloc): Ditto. + * os_dep.c (GC_get_maps, GC_remap, PROTECT, + GC_write_fault_handler, GC_dirty_init, GC_mprotect_thread): Ditto. + * alloc.c (min_bytes_allocd): Use GC_log_printf instead of + GC_printf for DEBUG_THREADS output. + * darwin_stop_world.c (GC_stack_range_for, GC_suspend_thread_list, + GC_stop_world, GC_thread_resume, GC_start_world): Ditto. + * pthread_start.c (GC_inner_start_routine): Ditto. + * pthread_stop_world.c (GC_suspend_handler, GC_restart_handler, + GC_push_all_stacks, GC_suspend_all, GC_stop_world, + GC_start_world): Ditto. + * pthread_support.c (GC_mark_thread, GC_get_nprocs, + GC_start_rtn_prepare_thread, pthread_create): Ditto. + * alloc.c (GC_adj_bytes_allocd, GC_maybe_gc, GC_stopped_mark, + GC_finish_collection): Reformat code. + * pthread_stop_world.c (GC_print_sig_mask): Ditto. + * pthread_support.c (GC_thr_init): Ditto. + * checksums.c (GC_update_check_page): Use GC_printf() instead of + GC_err_printf() for error printing. + * checksums.c (GC_check_blocks, GC_check_dirty): Use GC_log_printf + instead of GC_printf for logging purposes. + * dyn_load.c (sys_errlist, sys_nerr, errno): Move declaration of + external variable outside from GC_register_dynamic_libraries. + * dyn_load.c (GC_register_dynamic_libraries): Don't use + sys_errlist value if errno equals to sys_nerr. + * dyn_load.c (GC_register_dynamic_libraries): Use GC_log_printf + instead of GC_printf for DL_VERBOSE output. + * dyn_load.c (GC_dyld_image_add, GC_dyld_image_remove, + GC_init_dyld): Use GC_log_printf instead of GC_printf for + DARWIN_DEBUG output. + * os_dep.c (catch_exception_raise): Use GC_log_printf + instead of GC_printf for DEBUG_EXCEPTION_HANDLING output. + * reclaim.c (GC_print_free_list): Move "n" increment out of + GC_printf() call. + +2011-04-03 Ivan Maidanski + + * win32_threads.c (DEBUG_CYGWIN_THREADS, DEBUG_WIN32_PTHREADS, + DEBUG_WIN32_THREADS): Remove. + * win32_threads.c (GC_register_my_thread_inner, + GC_win32_start_inner): Use GC_log_printf instead of GC_printf + inside "if (GC_print_stats)" branch. + * win32_threads.c (GC_PTHREAD_PTRVAL): New macro (defined only if + GC_PTHREADS). + * win32_threads.c (GC_delete_gc_thread, NUMERIC_THREAD_ID, + GC_pthread_join, GC_pthread_create): Use GC_PTHREAD_PTRVAL + macro. + * win32_threads.c (GC_push_stack_for, GC_mark_thread, + GC_CreateThread, GC_beginthreadex, GC_pthread_join, + GC_pthread_create, GC_pthread_start_inner, GC_thread_exit_proc, + GC_mark_thread_local_free_lists): Use GC_log_printf instead of + GC_printf for DEBUG_THREADS output. + * win32_threads.c (GC_win32_start_inner, GC_CreateThread, + GC_beginthreadex, GC_pthread_join, GC_pthread_create, + GC_pthread_start_inner, GC_thread_exit_proc): Cast + GetCurrentThreadId result to long; don't cast value of pthread_t + type to int; adjust printf format specifiers. + * doc/README.win32 (DEBUG_WIN32_PTHREADS): Remove obsolete + information. + +2011-04-03 Ivan Maidanski + + * tests/test.c (cons, small_cons, gcj_cons, check_ints, + check_uncollectable_ints, print_int_list, check_marks_int_list, + fork_a_thread, finalizer, mktree, chktree, alloc8bytes, + alloc_small, tree_test, typed_test, check_heap_stats, WinMain, + test, main): Remove unnecessary casts of GC_printf calls to void. + +2011-04-02 Ivan Maidanski + + * allchblk.c (GC_print_hblkfreelist): Adjust (make uniform across + BDWGC) printed message (adjust letters case, terminating dot and + new line symbols). + * alloc.c (GC_check_fl_marks): Ditto. + * backgraph.c (new_back_edges): Ditto. + * checksums.c (GC_check_dirty): Ditto. + * darwin_stop_world.c (GC_push_all_stacks, + GC_suspend_thread_list): Ditto. + * dbg_mlc.c (GC_print_type, GC_debug_free, GC_debug_realloc, + store_old): Ditto. + * dyn_load.c (GC_register_dynamic_libraries): Ditto. + * mark.c (GC_initiate_gc, GC_mark_some, GC_mark_from, GC_push_all, + GC_push_selected, GC_push_next_marked_dirty): Ditto. + * mark_rts.c (GC_exclude_static_roots_inner): Ditto. + * os_dep.c (GC_remap, GC_default_push_other_roots, + GC_push_thread_structures, GC_dirty_init, GC_read_dirty, + catch_exception_raise_state, catch_exception_raise_state_identity, + GC_mprotect_thread_notify, GC_mprotect_thread, + catch_exception_raise): Ditto. + * pthread_stop_world.c (GC_print_sig_mask, GC_push_all_stacks, + GC_stop_world, GC_stop_init): Ditto. + * pthread_support.c (GC_thr_init, GC_register_my_thread_inner, + GC_start_routine): Ditto. + * win32_threads.c (GC_register_my_thread_inner, + GC_push_all_stacks, GC_win32_start_inner, GC_pthread_join, + GC_pthread_start_inner): Ditto. + * alloc.c (GC_expand_hp_inner): Realign the code. + * mark.c (GC_mark_from, GC_mark_local, GC_do_parallel_mark): + Ditto. + * misc.c (GC_init): Ditto. + * os_dep.c (GC_dirty_init, GC_read_dirty): Ditto. + * include/private/gc_pmark.h (PUSH_CONTENTS_HDR): Ditto. + * tests/test.c (run_one_test): Ditto. + * misc.c (GC_err_puts): Document. + * misc.c (GC_err_write): Remove. + * os_dep.c (dump_maps): Ditto. + * include/private/gc_priv.h (GC_err_write): Ditto. + * os_dep.c (GC_print_address_map): Call GC_err_puts() instead of + dump_maps() and GC_err_write(). + * os_dep.c (GC_read_dirty): Remove redundant brackets. + +2011-04-02 Ivan Maidanski + + * tests/test.c (reverse_test_inner): Test interior pointer + recognition only if ALL_INTERIOR_POINTERS. + * tests/test.c (run_one_test): Replace GC_all_interior_pointers + with GC_get_all_interior_pointers(); simplify the expression. + * tests/test.c (check_heap_stats): Replace GC_bytes_allocd and + GC_bytes_allocd_before_gc with GC_get_total_bytes(). + * tests/test.c (main): Replace GC_gc_no with GC_get_gc_no(). + +2011-03-27 Ivan Maidanski + + * dbg_mlc.c (GC_debug_strdup, GC_debug_free): Output a portability + warning if the argument is NULL and GC is in leaks detection mode. + * dbg_mlc.c (GC_debug_strndup, GC_debug_wcsdup): New public + function definition. + * malloc.c (GC_strndup, GC_wcsdup, strndup): Ditto. + * mallocx.c (GC_posix_memalign): Ditto. + * malloc.c (strdup): Fix string size value; rename "len" to "lb". + * mallocx.c: Include errno.h unless WinCE (otherwise include + windows.h for Win32 error constants). + * win32_threads.c: Define WIN32_LEAN_AND_MEAN and NOSERVICE before + windows.h inclusion. + * misc.c (GC_init): Register at-exit callback if GC_find_leak + (even if GC_FIND_LEAK macro is unset). + * pthread_stop_world.c (NACL_STORE_REGS, + __nacl_suspend_thread_if_needed, GC_nacl_initialize_gc_thread): + Use BCOPY() instead of memcpy(). + * pthread_support.c (GC_init_real_syms): Ditto. + * doc/README: Update year in copyright. + * include/gc.h: Ditto. + * doc/README.macros (GC_DEBUG_REPLACEMENT, GC_REQUIRE_WCSDUP): + Document new macro. + * doc/README.macros (REDIRECT_MALLOC): Update documentation. + * include/gc.h (GC_strndup, GC_posix_memalign, GC_debug_strndup): + New API function prototype. + * include/gc.h (GC_MALLOC, GC_REALLOC): Redirect to + GC_debug_malloc/realloc_replacement() if GC_DEBUG_REPLACEMENT. + * include/gc.h (GC_STRDUP): Remove redundant parentheses. + * include/leak_detector.h (realloc, strdup): Ditto. + * include/gc.h (GC_STRNDUP): New API macro. + * include/gc.h (GC_NEW, GC_NEW_ATOMIC, GC_NEW_STUBBORN, + GC_NEW_UNCOLLECTABLE): Add missing parentheses. + * include/gc.h (GC_wcsdup, GC_debug_wcsdup): New API function + prototype (only if GC_REQUIRE_WCSDUP). + * include/gc.h (GC_WCSDUP): New API macro (only if + GC_REQUIRE_WCSDUP). + * include/leak_detector.h: Add copyright header; add usage + comment; include stdlib.h and string.h after gc.h (unless + GC_DONT_INCLUDE_STDLIB). + * include/leak_detector.h (malloc, calloc, free, realloc): + Undefine symbol before its redefinition. + * include/leak_detector.h (strndup, memalign, posix_memalign): + Redefine to the corresponding GC function. + * include/leak_detector.h (wcsdup): Redefine to GC_WCSDUP (only + if GC_REQUIRE_WCSDUP). + * include/leak_detector.h (CHECK_LEAKS): Add comment; don't define + the macro if already defined. + +2011-03-22 Ivan Maidanski + + * misc.c (GC_abort): Use _exit() (instead of DebugBreak) on Win32 + when doing code static analysis (to inform the tool that the + function is a no-return one). + * os_dep.c (GC_linux_stack_base): Remove a duplicate validation + of the length of "stat" file; use signed int type for "i", + "buf_offset" and "len" local variables (since read() may + return -1). + +2011-03-20 Ivan Maidanski + + * blacklst.c (GC_bl_init_no_interiors): New function (the code + moved from GC_bl_init). + * blacklst.c (GC_bl_init): Invoke GC_bl_init_no_interiors unless + GC_all_interior_pointers mode; remove unnecessarily parameter cast + for GC_scratch_alloc call. + * include/private/gc_priv.h (GC_bl_init): Move the function + declaration to misc.c file. + * misc.c (GC_bl_init_no_interiors): Add a prototype. + * misc.c (GC_set_all_interior_pointers): Allow values other than 0 + and 1; allow altering GC_set_all_interior_pointers value even + after GC initialization. + * obj_map.c (GC_initialize_offsets): Clear GC_valid_offsets and + GC_modws_valid_offsets if GC_all_interior_pointers is off. + * misc.c (GC_init): Don't call GC_initialize_offsets() unless + GC_all_interior_pointers mode. + +2011-03-20 Ivan Maidanski + + * alloc.c (GC_finish_collection): Remove redundant brackets; + adjust code indentation. + * blacklst.c (GC_add_to_black_list_normal): Simplify expression + (to improve code readability). + * blacklst.c (GC_is_black_listed): Join nested "if" (into a single + conditional expression); initialize "nblocks" just before the loop + beginning. + * misc.c (GC_init): Don't compute initial_heap_sz if GC is already + initialized. + * include/private/gc_priv.h (GC_initialize_offsets): Move the + function declaration to misc.c file. + * obj_map.c (GC_initialize_offsets): Remove offsets_initialized + static variable since the function is called only once. + * tests/middle.c: Include "gc.h" instead of ; expand all + tabs to spaces; adjust code indentation; replace the K&R-style + function definition with the ANSI C one. + * tests/smash_test.c: Ditto. + * tests/middle.c (main): Use setter for GC_all_interior_pointers; + adjust printf format specifier (and cast the value passed to). + +2011-03-15 Ivan Maidanski + + * doc/README.macros (SMALL_CONFIG, LARGE_CONFIG): Refine the + documentation. + * include/private/gc_hdrs.h (LOG_BOTTOM_SZ): Ignore SMALL_CONFIG + if LARGE_CONFIG is defined. + * include/private/gc_priv.h (CPP_LOG_HBLKSIZE): Ditto. + +2011-03-15 Ivan Maidanski + + * alloc.c (GC_finish_collection): Replace "#else #ifdef" with + "#elif". + * include/private/gc_priv.h (CPP_LOG_HBLKSIZE, LOG_PHT_ENTRIES, + MAX_ROOT_SETS, MAX_HEAP_SECTS): Ditto. + * alloc.c (GC_expand_hp_inner): Check for GC_collect_at_heapsize + overflow even if not LARGE_CONFIG. + * dbg_mlc.c (GC_check_heap_proc): Check "oh" size even if + SMALL_CONFIG. + * finalize.c (GC_print_finalization_stats): Fix "#endif" comment. + * new_hblk.c (GC_build_fl_clear2, GC_build_fl_clear4, GC_build_fl2, + GC_build_fl4): Reformat the comment; adjust code indentation. + * new_hblk.c (GC_build_fl): Fix indentation. + * include/private/gc_hdrs.h: Ditto. + * doc/README.environment (GC_LOG_FILE, GC_PRINT_VERBOSE_STATS, + GC_FULL_FREQUENCY): Refine the documentation. + +2011-03-13 Ivan Maidanski + + * extra/msvc_dbg.c: Test _MSC_VER macro; include "gc.h" (for + GC_word); reformat the code; expand all tabs to spaces. + * extra/msvc_dbg.c (ULONG_PTR): Replace with GC_ULONG_PTR; define + as word. + +2011-03-13 Ivan Maidanski + + * dbg_mlc.c (GC_get_back_ptr_info, GC_print_obj, + GC_print_smashed_obj, GC_debug_free_inner): Add a code for a + LINT-like tool to instruct it that the function is invoked only + with valid parameters (otherwise a SEGV is ok); recognize LINT2 + new macro. + * misc.c (GC_abort): Instruct a LINT-like tool that the function + never returns in fact. + * os_dep.c (GC_linux_stack_base): Check for read buffer overflow; + close the file immediately after read; use STRTOULL() instead of + decoding the address number manually. + * include/private/gc_priv.h (EXPECT): Don't specify outcome for a + LINT-like tool. + * include/private/gc_priv.h (GC_all_interior_pointers): Instruct a + LINT-like tool that the value is restricted to zero and one only + (required since the variable is global and its value is used as a + part of array index expression is some places). + +2011-03-13 Ivan Maidanski + + * dbg_mlc.c (GC_make_closure): Fix SEGV in case GC_malloc returns + NULL. + * dbg_mlc.c (GC_debug_register_finalizer, + GC_debug_register_finalizer_no_order, + GC_debug_register_finalizer_unreachable, + GC_debug_register_finalizer_ignore_self): Handle out of memory + case properly (similar to GC_register_finalizer_inner). + * headers.c (GC_install_header): Handle the case when alloc_hdr() + returns NULL. + * os_dep.c (GC_get_maps_len): Defend against missing "maps" file. + * pthread_support.c (GC_mark_thread): Place a dummy return + statement (which uses "id" argument) before the actual use of "id" + as an array index (to suppress a warning produced by some static + code analysis tools). + * win32_threads.c (GC_mark_thread): Ditto. + * pthread_support.c (GC_thr_init): Abort (with the appropriate + message) if out of memory. + +2011-03-13 Ivan Maidanski + + * finalize.c (GC_register_finalizer_inner): Fix a typo in a + comment. + *include/private/gcconfig.h (STACKBOTTOM): Ditto. + * gcj_mlc.c (GC_core_gcj_malloc): Replace 0/1 with TRUE/FALSE in + EXPECT (the 2nd argument). + * malloc.c (GC_core_malloc_atomic, GC_core_malloc, GC_free): + Ditto. + * mark.c (GC_mark_and_push, GC_mark_and_push_stack): Ditto. + * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Ditto. + * include/private/gc_hdrs.h (HC_GET_HDR): Ditto. + * include/private/gc_priv.h (SMALL_OBJ): Ditto. + * include/private/specific.h (getspecific): Ditto. + * pthread_support.c (LOCK_STATS): Add a comment. + +2011-03-08 Ivan Maidanski + + * include/gc_pthread_redirects.h (GC_NO_DLOPEN, + GC_NO_PTHREAD_SIGMASK, GC_PTHREAD_CREATE_CONST, + GC_PTHREAD_EXIT_ATTRIBUTE, GC_NO_PTHREAD_CANCEL): Move the + definition to gc_config_macros. + +2011-03-08 Ivan Maidanski + + * pthread_support.c (pthread_cancel, GC_pthread_cancel_t, + GC_pthread_cancel): Test GC_NO_PTHREAD_CANCEL (instead of NACL and + GC_PTHREAD_EXIT_ATTRIBUTE). + * include/gc_pthread_redirects.h (GC_pthread_cancel, + pthread_cancel): Ditto. + * pthread_support.c (GC_pthread_create, GC_pthread_sigmask, + GC_pthread_join, GC_pthread_detach, GC_pthread_cancel): Realign + code. + * include/gc_pthread_redirects.h (GC_PTHREAD_EXIT_ATTRIBUTE): + Define as empty for NaCl. + * include/gc_pthread_redirects.h (GC_NO_PTHREAD_CANCEL): New macro + defined. + +2011-03-07 Ivan Maidanski + + * dyn_load.c (GC_init_dyld): Do not invoke + _dyld_bind_fully_image_containing_address() if GC_no_dls (as it is + not required to register the main data segment in that case). + * include/gc.h (GC_no_dls): Adjust the comment. + +2011-03-07 Ivan Maidanski + + * dyn_load.c (GC_MUST_RESTORE_REDEFINED_DLOPEN): Test + GC_NO_DLOPEN. + * gc_dlopen.c: Ditto. + * include/gc_pthread_redirects.h (GC_dlopen, dlopen): Ditto. + * gc_dlopen.c: Don't include dlfcn.h (as it is included in + gc_pthread_redirects.h). + * pthread_support.c (pthread_sigmask, GC_pthread_sigmask_t, + GC_pthread_sigmask): Test GC_NO_PTHREAD_SIGMASK (instead of + GC_DARWIN_THREADS, GC_OPENBSD_THREADS and NACL). + * include/gc_pthread_redirects.h (GC_pthread_sigmask, + pthread_sigmask): Ditto. + * win32_threads.c (pthread_sigmask, GC_pthread_sigmask): Test + GC_NO_PTHREAD_SIGMASK (instead of GC_WIN32_PTHREADS); reformat the + comment. + * pthread_support.c (pthread_create, GC_pthread_create_t, + GC_pthread_create): Rename GC_PTHREAD_CONST to + GC_PTHREAD_CREATE_CONST. + * win32_threads.c (GC_pthread_create): Ditto. + * include/gc_pthread_redirects.h: Ditto. + * include/gc_pthread_redirects.h (GC_NO_DLOPEN, + GC_NO_PTHREAD_SIGMASK): New macro defined. + * include/gc_pthread_redirects.h (GC_PTHREAD_CREATE_CONST): Set to + empty for NaCl. + * include/gc_pthread_redirects.h (GC_PTHREAD_EXIT_ATTRIBUTE): Do + not define for Android (as CANCEL_SAFE is not defined). + +2011-03-07 Ivan Maidanski + + * include/gc.h (GC_ADD_CALLER, GC_RETURN_ADDR, + GC_HAVE_BUILTIN_BACKTRACE, GC_CAN_SAVE_CALL_STACKS): Move + definition to gc_config_macros.h file. + * include/gc_config_macros.h: Check the file is included from gc.h + file. + * include/gc_version.h: Ditto. + * include/gc_config_macros.h: Reformat comments. + * include/gc_version.h: Reformat code. + +2011-02-20 Ivan Maidanski (mostly really Elijah Taylor) + + * gc_dlopen.c: Empty unit for NaCl. + * os_dep.c: Include fcntl.h for NaCl. + * os_dep.c (GC_get_main_stack_base): Ignore + USE_GET_STACKBASE_FOR_MAIN macro for NaCl. + * os_dep.c (GC_get_stack_base): Return GC_UNIMPLEMENTED for NaCl. + * os_dep.c (GC_remap): Use mmap (instead of mprotect) for NaCl. + * pthread_start.c (GC_inner_start_routine): Don't invoke + pthread_cleanup_push/pop for NaCl. + * pthread_stop_world.c (GC_nacl_num_gc_threads, + GC_nacl_thread_idx, GC_nacl_park_threads_now, + GC_nacl_thread_parker, GC_nacl_gc_thread_self, + GC_nacl_thread_parked, GC_nacl_thread_used, + GC_nacl_thread_parking_inited, GC_nacl_thread_alloc_lock): New + variable (fo NaCl only). + * pthread_stop_world.c (GC_suspend_handler): Reformat the code. + * pthread_stop_world.c (GC_remove_allowed_signals, + suspend_handler_mask, GC_stop_count, GC_world_is_stopped, + GC_retry_signals, SIG_THR_RESTART, GC_suspend_ack_sem, + GC_restart_ack_sem, GC_suspend_handler_inner, GC_suspend_handler, + GC_restart_handler): Don't define for NaCl. + * pthread_support.c (GC_get_nprocs): Ditto. + * include/private/gc_priv.h (SIG_SUSPEND): Ditto. + * include/private/gcconfig.h (LINUX): Ditto. + * pthread_stop_world.c (GC_push_all_stacks): Push register storage + for NaCl. + * pthread_stop_world.c (GC_suspend_all, GC_stop_world, + GC_start_world): Implement for NaCl. + * pthread_stop_world.c (GC_stop_world): Don't define unused "i" + local variable for OpenBSD (and NaCl). + * pthread_stop_world.c (NACL_STORE_REGS): New macro definition for + NaCl. + * pthread_stop_world.c (nacl_pre_syscall_hook, + __nacl_suspend_thread_if_needed, nacl_post_syscall_hook, + GC_nacl_initialize_gc_thread, GC_nacl_shutdown_gc_thread): New + function (for NaCl only). + * pthread_stop_world.c (GC_stop_init): Empty for NaCl. + * pthread_support.c (pthread_cancel, pthread_sigmask): Don't + redirect for NaCl. + * include/gc_pthread_redirects.h (pthread_cancel, + pthread_sigmask): Ditto. + * pthread_support.c (GC_nacl_initialize_gc_thread, + GC_nacl_shutdown_gc_thread): New internal prototype (NaCl only). + * pthread_support.c (GC_new_thread, GC_delete_thread): Initialize + and shutdown thread for NaCl. + * pthread_support.c (GC_thr_init): Call sysconf for NaCl. + * pthread_support.c (GC_pthread_exit): Call GC_thread_exit_proc + for NaCl. + * include/gc.h: Don't include features.h for NaCl. + * include/gc_pthread_redirects.h (GC_PTHREAD_CONST): New macro. + * include/gc_pthread_redirects.h (GC_pthread_create): Use + GC_PTHREAD_CONST instead of const. + * win32_threads.c (GC_pthread_create): Ditto. + * pthread_support.c (GC_pthread_create_t, GC_pthread_create, + pthread_create): Ditto. + * include/private/gcconfig.h (NACL): Recognize NaCl. + * include/private/gcconfig.h (GC_LINUX_THREADS): Valid for NaCl. + * include/private/pthread_stop_world.h (thread_stop_info): Add + reg_storage member; define NACL_GC_REG_STORAGE_SIZE macro (for + NaCl only). + * include/private/pthread_support.h (GC_nacl_gc_thread_self): + Declare internal variable (for NaCl only). + +2011-02-19 Ivan Maidanski + + * aclocal.m4: Regenerate (by autoreconf -vif using autoconf-2.68, + automake-1.11.1 and libtool-2.4). + * configure: Ditto. + * ltmain.sh: Ditto. + * makefile.in: Ditto. + * m4/libtool.m4: Ditto. + * m4/ltversion.m4: Ditto. + * mach_dep.c (GC_with_callee_saves_pushed): Fix FE_ALL_EXCEPT + macro. + +2011-02-13 Ivan Maidanski + + * mark.c (GC_mark_some): Prefix and suffix "asm" and "volatile" + keywords with double underscore. + * os_dep.c (GC_unix_get_mem): Reformat the code. + * os_dep.c (catch_exception_raise, catch_exception_raise_state, + catch_exception_raise_state_identity): Add GC_API_OSCALL to + function definition. + * os_dep.c (catch_exception_raise_state, + catch_exception_raise_state_identity): Move definition to be + before GC_ports. + * os_dep.c (catch_exception_raise): Declare to have the symbol + defined before GC_ports. + * os_dep.c (GC_ports): Store references to catch_exception_raise, + catch_exception_raise_state, catch_exception_raise_state_identity + (to prevent stripping these symbols as dead). + * os_dep.c (catch_exception_raise, catch_exception_raise_state, + catch_exception_raise_state_identity): Mark these symbols as + "referenced dynamically" via an assembler directive (unless + NO_DESC_CATCH_EXCEPTION_RAISE). + * include/private/gc_priv.h (GC_API_OSCALL): New macro (defined + similar to GC_API but as if GC_DLL is always defined). + +2011-02-10 Ivan Maidanski (with input from Dimitry Andric) + + * os_dep.c: Don't include signal.h for GC_write_fault_handler on + Win32. + * os_dep.c (SIG_OK): Don't return true unless SIGSEGV or SIGBUS on + FreeBSD. + * os_dep.c (CODE_OK): Use SEGV_ACCERR on FreeBSD (define + SEGV_ACCERR for older FreeBSD releases). + * os_dep.c (SIG_OK, CODE_OK, GC_write_fault_handler): Reformat the + code. + +2011-02-10 Ivan Maidanski + + * dyn_load.c (GC_register_map_entries, + GC_register_dynamic_libraries_dl_iterate_phdr): Calculate + DATASTART only once if DATASTART_IS_FUNC. + * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr): + Calculate DATAEND only once if DATAEND_IS_FUNC. + * dyn_load.c: Add comment to some endif; realign some code. + * dyn_load.c (GC_init_dyld): Don't use + _dyld_bind_fully_image_containing_address if + NO_DYLD_BIND_FULLY_IMAGE defined; add FIXME. + * include/private/gcconfig.h (GC_data_start, GC_find_limit): + Declare if used by DATASTART/DATAEND, respectively. + * include/private/gcconfig.h (DATASTART_IS_FUNC, DATAEND_IS_FUNC): + Define if DATASTART/DATAEND is a function, respectively. + * include/private/gcconfig.h (GETPAGESIZE, NO_PTHREAD_TRYLOCK, + NO_DYLD_BIND_FULLY_IMAGE): Define for Darwin/arm as well; include + unistd.h. + +2011-02-10 Ivan Maidanski + + * os_dep.c (GC_setpagesize, GC_task_self, PROTECT, UNPROTECT): + Reorder to remove redundant ifdef for Win32. + * os_dep.c: Add comment to some endif. + * os_dep.c: Include pthread.h (for Linux even if single-threaded) + if USE_GET_STACKBASE_FOR_MAIN; also include it for Darwin. + * os_dep.c (STACKBOTTOM): Redefine for Darwin (unless prohibited + for some reason). + * os_dep.c (GC_get_main_stack_base): Allow + USE_GET_STACKBASE_FOR_MAIN for Linux even if single-threaded; add + assertion for the returned result. + * os_dep.c (GC_get_stack_base): Define for Darwin if + multi-threaded. + * os_dep.c (GC_page_was_dirty): Reformat the code. + * os_dep.c: Reformat some comments. + * os_dep.c (SIG_OK, CODE_OK): Add comment (for FreeBSD). + * os_dep.c (ID_STOP, ID_RESUME): Define only if threads. + * os_dep.c (catch_exception_raise): Remove redundant parentheses; + refine the documentation. + +2011-02-10 Ivan Maidanski + + * NT_MAKEFILE: Define _CRT_SECURE_NO_DEPRECATE for C++ files as + well. + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * doc/README.macros (USE_GET_STACKBASE_FOR_MAIN): Refine. + * include/gc.h (GC_INIT): Document. + * include/private/gc_priv.h (GC_MACH_HEADER, GC_MACH_SECTION, + GC_GETSECTBYNAME): Define depending only on the word size (i.e., + define these macros also for ARM). + * tests/test.c (check_heap_stats): Print main thread stack bottom + as well (only if verbose mode is on). + +2011-02-09 Ivan Maidanski (mostly Jean-Claude Beaudoin) + + * mach_dep.c (GC_with_callee_saves_pushed): Fix and improve code + introduced by the previous patch (if GETCONTEXT_FPU_EXCMASK_BUG + and X86_64). + +2011-01-22 Ivan Maidanski (mostly Jean-Claude Beaudoin) + + * darwin_stop_world.c (GC_FindTopOfStack): Prefix and suffix + "volatile" keyword with double underscore. + * mach_dep.c (GETCONTEXT_FPU_EXCMASK_BUG): Recognize new macro and + include fenv.h if defined (unless NO_GETCONTEXT or HAVE_PUSH_REGS). + * mach_dep.c (GC_with_callee_saves_pushed): Restore FPU exception + mask corrupted by getcontext if GETCONTEXT_FPU_EXCMASK_BUG. + * include/private/gcconfig.h (GETCONTEXT_FPU_EXCMASK_BUG): Define + for Linux/amd64 (since its GLibc getcontext currently has the bug). + +2011-01-17 Ivan Maidanski + + * allchblk.c (GC_use_entire_heap): Change type to int (as declared + in gc.h); set the default value depending on new GC_USE_ENTIRE_HEAP + macro. + * misc.c (GC_init): Test GC_USE_ENTIRE_HEAP environment variable to + alter the default value of GC_use_entire_heap. + * doc/README.environment (GC_USE_ENTIRE_HEAP): Document. + * doc/README.macros (GC_USE_ENTIRE_HEAP): Ditto. + +2011-01-12 Ivan Maidanski + + * include/private/gcconfig.h (PARALLEL_MARK): Do not make it cause + MPROTECT_VDB undefining. + +2011-01-07 Ivan Maidanski + + * gc_dlopen.c: Reformat the comments and adjust code indentation. + * include/private/gcconfig.h (DYNAMIC_LOADING): Fix filename in + the comment. + +2011-01-07 Ivan Maidanski + + * include/private/gc_priv.h (THREAD_FLD, MAX_HEAP_SECTS, + _GC_arrays, GC_push_all_stack_sections, PRINT_BLACK_LIST, + GC_add_to_black_list_stack, GC_ASSERT, SIG_SUSPEND, + NEED_FIND_LIMIT): Reformat the code and comments for. + * include/private/gc_priv.h (_GC_arrays): Move the conditional + macro definitions (shortcuts for GC_arrays members) into the + structure body. + +2011-01-07 Ivan Maidanski + + * .cvsignore: Add more auto-generated files. + * include/private/.cvsignore: Ditto. + * darwin_stop_world.c (GC_mach_handler_thread, + GC_use_mach_handler_thread, + GC_darwin_register_mach_handler_thread): Define only if + MPROTECT_VDB. + * darwin_stop_world.c (GC_suspend_thread_list): Use + GC_mach_handler_thread and GC_use_mach_handler_thread only if + MPROTECT_VDB. + * darwin_stop_world.c (GC_stop_world): Reset GC_mach_threads_count + only if defined (i.e. unless GC_NO_THREADS_DISCOVERY). + * misc.c (GC_init): Fix comment for GWW_VDB. + * os_dep.c (GC_mprotect_state_t): Reformat the code. + * os_dep.c (DARWIN_EXC_STATE, DARWIN_EXC_STATE_COUNT, + DARWIN_EXC_STATE_T, DARWIN_EXC_STATE_DAR): New macros. + * os_dep.c (catch_exception_raise): Use DARWIN_EXC_STATE, + DARWIN_EXC_STATE_COUNT, DARWIN_EXC_STATE_T, DARWIN_EXC_STATE_DAR; + reformat the comment. + * pthread_support.c (GC_thr_init): Define "dummy" local variable + only unless GC_DARWIN_THREADS; reformat the code. + * include/private/gcconfig.h (MPROTECT_VDB): Define for Darwin + even in the single-threaded mode; define for iPhone/iPad. + * include/private/gcconfig.h (IA64): Remove unnecessary "ifdef" + around "undef". + * include/private/gcconfig.h (HEURISTIC1): Remove unused for + Cygwin. + * include/private/gcconfig.h (STACKBOTTOM): Use fixed address for + Darwin/arm (instead of HEURISTIC1). + * include/private/gcconfig.h (GET_MEM): Reformat the code. + +2011-01-05 Ivan Maidanski + + * misc.c (GC_write): Replace multiple "ifdef/endif" with "elif" + (for ECOS and NOSYS). + * os_dep.c (GC_get_main_stack_base): Ditto. + * os_dep.c (GC_get_main_stack_base): Check + USE_GET_STACKBASE_FOR_MAIN macro before checking STACKBOTTOM one; + remove "dummy" variable (use result one instead); reformat the + code. + * doc/README.macros (SN_TARGET_PS3): Document. + * extra/threadlibs.c (main): Don't output "-lpthread" (and "-ldl") + for Android. + * include/private/pthread_support.h: Fix comment for "endif". + +2010-12-26 Ivan Maidanski (mostly really Miguel de Icaza) + + * misc.c (GC_allocate_ml): Define global variable if SN_TARGET_PS3. + * misc.c (GC_init): Initialize GC_allocate_ml if SN_TARGET_PS3. + * os_dep.c (SIGSEGV): Define to dummy zero if SN_TARGET_PS3. + * os_dep.c (GC_unix_mmap_get_mem): Don't define if SN_TARGET_PS3. + * os_dep.c (GC_default_push_other_roots, + GC_push_thread_structures): Define for SN_TARGET_PS3. + * include/private/gc_locks.h (GC_allocate_ml, LOCK, UNLOCK): Define + for SN_TARGET_PS3. + * include/private/gcconfig.h (SN_TARGET_PS3): Recognize new macro + (Sony PS/3 target). + * include/private/gcconfig.h (THREADS): Define unconditionally if + SN_TARGET_PS3. + * include/private/gcconfig.h (GET_MEM): Define for SN_TARGET_PS3. + +2010-12-26 Ivan Maidanski + + * alloc.c (GC_collect_or_expand): Replace NIL with NULL in message. + * dbg_mlc.c (GC_debug_malloc, GC_debug_malloc_ignore_off_page, + GC_debug_malloc_atomic_ignore_off_page, + GC_debug_generic_malloc_inner, + GC_generic_malloc_inner_ignore_off_page, GC_debug_malloc_stubborn, + GC_debug_malloc_atomic, GC_debug_malloc_uncollectable, + GC_debug_malloc_atomic_uncollectable): Ditto. + * gcj_mlc.c (GC_debug_gcj_malloc): Ditto. + * dbg_mlc.c (GC_check_annotated_obj): Replace NIL with NULL in a + comment. + * dyn_load.c (GC_FirstDLOpenedLinkMap): Ditto. + * mark_rts.c (GC_roots_present): Ditto. + * doc/README: Ditto. + * include/private/gc_hdrs.h (IS_FORWARDING_ADDR_OR_NIL): Ditto. + * include/private/gc_priv.h (_GC_arrays): Ditto. + +2010-12-26 Ivan Maidanski (mostly really Geoff Norton + and Jonathan Pryor) + + * configure.ac: Use AC_CHECK_LIB() to check for pthread instead of + just blindly linking to -lpthread, as Android includes pthread + support within libc and does not provide a separate libpthread. + * dyn_load.c (GC_register_dynamic_libraries): Skip current link map + entry if l_addr is NULL (Android/bionic only). + * pthread_stop_world.c (android_thread_kill): New internal function + (Android only). + * pthread_stop_world.c (GC_suspend_all, GC_start_world): Call + android_thread_kill (based on tkill) instead of pthread_kill on + Android (since pthread_kill cannot be used safely on the platform). + * pthread_support.c (GC_new_thread): Store thread Id (obtained from + gettid) for use by android_thread_kill (Android only). + * include/private/pthread_support.h (GC_Thread_Rep): Add kernel_id + structure member (Android only). + * include/private/gcconfig.h: Recognize __x86_64 macro as a synonym + of __x86_64__ (Darwin); define __environ macro (Android on M68K). + * configure: Regenerate. + +2010-12-02 Ivan Maidanski + + * allchblk.c (GC_freehblk): Print extended error message (done via + GC_printf() before aborting with a short message) only if + GC_print_stats. + * dyn_load.c (GC_register_dynamic_libraries): Ditto. + * os_dep.c (GC_get_maps, GC_register_data_segments, GC_remap, + PROTECT, GC_write_fault_handler, GC_mprotect_thread): Ditto. + * pthread_stop_world.c (GC_start_world): Ditto. + * win32_threads.c (GC_register_my_thread_inner): Ditto. + * os_dep.c (GC_get_main_stack_base, GC_register_data_segments, + GC_dirty_init): Remove redundant print of an error message before + aborting with the same message. + * os_dep.c (GC_register_data_segments): Remove format specifier + from the string passed to GC_err_puts(); use ABORT instead of EXIT + (if invalid executable type). + * os_dep.c (GC_remap): Adjust printf format specifier (for long + type). + * os_dep.c (GC_dirty_init): Print a message about SIG_IGN detected + (for SIGSEGV/BUS) only if GC_print_stats. + * os_dep.c (catch_exception_raise): Join 2 adjacent GC_err_printf + calls. + +2010-11-25 Ivan Maidanski + + * tests/test.c (main): Print the relevant message if GWW_VDB. + * include/private/gcconfig.h: Don't define MPROTECT_VDB for Win32 + on x64 if compiled by GCC. + +2010-11-04 Ivan Maidanski + + * tests/staticrootstest.c: Include string.h for memset() prototype. + * tests/thread_leak_test.c (main): Fix printf() format specifiers. + +2010-10-22 Ivan Maidanski + + * CMakeLists.txt: Check enable_parallel_mark on Darwin. + * configure.ac: Ditto. + * darwin_stop_world.c (DARWIN_SUSPEND_GC_THREADS, + DARWIN_QUERY_TASK_THREADS): Rename to GC_NO_THREADS_DISCOVERY and + GC_DISCOVER_TASK_THREADS, respectively. + * os_dep.c (DARWIN_SUSPEND_GC_THREADS): Ditto. + * pthread_support.c (DARWIN_SUSPEND_GC_THREADS): Ditto. + * darwin_stop_world.c (DARWIN_QUERY_TASK_THREADS): Don't define + (and remove FIXME). + * darwin_stop_world.c (GC_use_threads_discovery): Add GC_API; + comment; remove FIXME. + * win32_threads.c (GC_NO_DLLMAIN): Rename to + GC_NO_THREADS_DISCOVERY. + * tests/test.c (GC_NO_DLLMAIN): Ditto. + * doc/README.macros (GC_NO_DLLMAIN): Ditto. + * doc/README.win32 (GC_NO_DLLMAIN): Ditto. + * doc/README.macros (GC_NO_THREADS_DISCOVERY): Update the comment. + * win32_threads.c (GC_win32_dll_threads): Define as macro to true + if GC_DISCOVER_TASK_THREADS (and not GC_NO_THREADS_DISCOVERY); + update the comment. + * win32_threads.c (GC_use_DllMain): Rename to + GC_use_threads_discovery; do not set GC_win32_dll_threads if + GC_DISCOVER_TASK_THREADS. + * win32_threads.c (GC_started_thread_while_stopped, + GC_lookup_thread_inner, UNPROTECT_THREAD, GC_lookup_pthread, + GC_thr_init, GC_pthread_create, DllMain): Rewrite some expressions + which use GC_win32_dll_threads to minimize the possibility of + an "unreachable code" compiler warning when GC_win32_dll_threads + is defined as a macro. + * win32_threads.c (GC_unregister_my_thread): Don't call + GC_delete_thread() if GC_win32_dll_threads and THREAD_LOCAL_ALLOC + (since can't happen); use "t" local variable only if not + GC_win32_dll_threads. + * win32_threads.c (GC_register_my_thread_inner): Reformat the + comment. + * doc/README.macros (GC_DISCOVER_TASK_THREADS): Document. + * include/gc.h (GC_use_DllMain): Rename to + GC_use_threads_discovery but keep old name as a macro definition. + * include/gc.h (GC_use_threads_discovery): Declare also for + Darwin; update the comment. + * tests/test.c (main): Call GC_use_threads_discovery for Darwin + (to test the mode if possible). + * configure: Regenerate. + +2010-10-16 Ivan Maidanski + + * darwin_stop_world.c (DARWIN_SUSPEND_GC_THREADS, + DARWIN_QUERY_TASK_THREADS): New macro recognized. + * darwin_stop_world.c (GC_query_task_threads): add STATIC; + initialize to false; define as macro if DARWIN_SUSPEND_GC_THREADS + or DARWIN_QUERY_TASK_THREADS; remove FIXME. + * darwin_stop_world.c (GC_use_threads_discovery): New function + (for setting GC_query_task_threads value). + * darwin_stop_world.c (GC_mach_handler_thread, + GC_use_mach_handler_thread, GC_mach_thread, GC_MAX_MACH_THREADS, + GC_mach_threads, GC_mach_threads_count, GC_suspend_thread_list, + GC_darwin_register_mach_handler_thread): Define only if not + DARWIN_SUSPEND_GC_THREADS. + * darwin_stop_world.c (GC_stop_world, GC_start_world): Exclude + the code for GC_query_task_threads case from compilation unless + DARWIN_SUSPEND_GC_THREADS. + * os_dep.c (GC_darwin_register_mach_handler_thread): Declared only + if Darwin threads and not DARWIN_SUSPEND_GC_THREADS. + * os_dep.c (GC_mprotect_thread): Call + GC_darwin_register_mach_handler_thread only if THREADS and not + DARWIN_SUSPEND_GC_THREADS. + * pthread_support.c (marker_mach_threads): Don't define if + DARWIN_SUSPEND_GC_THREADS. + * pthread_support.c (GC_mark_thread): Don't fill in + marker_mach_threads if DARWIN_SUSPEND_GC_THREADS. + * include/private/gc_locks.h (GC_need_to_lock): Always declare for + THREADS case. + +2010-10-15 Ivan Maidanski + + * darwin_stop_world.c (GC_query_task_threads): Don't define to + false for DARWIN_DONT_PARSE_STACK case; unconditionally initialize + the variable to false (for now). + * darwin_stop_world.c (GC_push_all_stacks): Call task_threads() + only if not DARWIN_DONT_PARSE_STACK. + * darwin_stop_world.c (GC_stop_world, GC_start_world): Use the + approach based on task_threads() only if GC_query_task_threads + else use GC_threads table. + +2010-10-15 Ivan Maidanski + + * darwin_stop_world.c (GC_mach_threads): Remove static qualifier. + * darwin_stop_world.c (GC_stop_init): Remove (as we do not need to + really clear GC_mach_threads[]). + * darwin_stop_world.c (GC_stop_world): Reset GC_mach_threads_count + (instead of calling GC_stop_init). + * include/private/pthread_support.h (GC_stop_init): Remove proto. + * pthread_support.c (GC_stop_init): Add proto (unless Darwin). + * pthread_support.c (GC_thr_init): Don't call GC_stop_init() if + GC_DARWIN_THREADS. + +2010-10-14 Ivan Maidanski + + * darwin_stop_world.c (GC_stack_range_for): New static function + (move the code from GC_push_all_stacks). + * darwin_stop_world.c (GC_push_all_stacks): Call + GC_stack_range_for(); rename kern_return local variable to + kern_result. + * darwin_stop_world.c (GC_is_mach_marker): Change argument type + from mach_port_t to thread_act_t. + * pthread_support.c (GC_is_mach_marker): Ditto. + +2010-10-12 Ivan Maidanski + + * darwin_stop_world.c (GC_push_all_stacks): Fix "my_task" local + variable initialization (always call current_task()). + * pthread_support.c (GC_thr_init, GC_register_my_thread_inner): + Don't set thread's stop_info.stack_ptr value for Darwin. + * include/private/darwin_stop_world.h (thread_stop_info): Update + the comment for stack_ptr. + +2010-10-10 Ivan Maidanski + + * darwin_stop_world.c (GC_push_all_stacks): Rename "r", "me" local + variables to "kern_return" and "my_thread" ones, respectively; + call mach_port_deallocate() unconditionally. + * darwin_stop_world.c (GC_stop_world): Don't call mach_thread_self + if DEBUG_THREADS. + +2010-10-09 Ivan Maidanski + + * darwin_stop_world.c (GC_mach_thread): Move from + darwin_stop_world.h. + * include/private/darwin_stop_world.h (GC_mach_thread): Remove. + * win32_threads.c (GC_start_world): Define "thread_id" local + variable only if GC_ASSERTIONS; decide whether to resume a thread + based on its "suspended" field value; assert that suspended thread + stack_base is non-zero and the thread is not our one. + +2010-10-08 Ivan Maidanski + + * darwin_stop_world.c (GC_thread_resume): New inline function + (move code from GC_thread_resume). + * darwin_stop_world.c (GC_start_world): Check result of + task_threads(); call GC_thread_resume(). + * os_dep.c (GC_malloc_heap_l, GC_is_malloc_heap_base): Define + only if not CYGWIN32. + * os_dep.c (GC_is_heap_base): Call GC_is_malloc_heap_base() only + if not CYGWIN32. + +2010-10-06 Ivan Maidanski + + * darwin_stop_world.c (FindTopOfStack): Change return type to + ptr_t (from long); make GC_INNER; add GC_ prefix. + * darwin_stop_world.c (GC_push_all_stacks): Add thread_blocked + local variable (initialized from the corresponding GC_thread + field unless GC_query_task_threads); add assertion that our + thread is not blocked; prefix FindTopOfStack with GC_ and remove + no longer needed cast to ptr_t of the result; handle thread + blocked case (and remove FIXME); use GC_push_all_stack_sections + unless GC_query_task_threads (and remove FIXME). + * pthread_support.c (GC_FindTopOfStack): Declare (if needed). + * pthread_support.c (GC_do_blocking_inner): Call + GC_save_regs_in_stack (if needed) before acquiring the lock. + * win32_threads.c (GC_do_blocking_inner): Ditto. + * pthread_support.c (GC_do_blocking_inner): Set/clear topOfStack + field of GC_thread (Darwin only). + * include/private/pthread_support.h (GC_thread): Add topOfStack + field for Darwin (unless DARWIN_DONT_PARSE_STACK). + +2010-10-05 Ivan Maidanski + + * finalize.c (GC_check_finalizer_nested): Change return type to + char pointer (instead of int pointer); use explicit cast for + GC_finalizer_nested assignment. + * pthread_support.c (GC_check_finalizer_nested): Ditto. + * win32_threads.c (GC_check_finalizer_nested): Ditto. + * finalize.c (GC_finalizer_nested): Change type to unsigned char. + * finalize.c (GC_notify_or_invoke_finalizers): Change type of + "pnested" local variable to char pointer. + * pthread_support.c (GC_do_blocking_inner, + GC_call_with_gc_active): Use explicit cast for "thread_blocked" + field assignment. + * win32_threads.c (GC_lookup_pthread): Use explicit cast for + "suspended" field assignment. + * win32_threads.c (GC_Thread_Rep): Use short type for + finalizer_skipped; use char type for finalizer_nested and flags + fields and reorder some fields (to minimize GC_Thread_Rep + structure size). + * include/private/pthread_support.h (GC_Thread_Rep): Ditto. + * win32_threads.c (GC_Thread_Rep): Use char type for suspended + field (instead of GC_bool). + * include/private/pthread_support.h (GC_Thread_Rep): Use char type + for thread_blocked field (instead of short). + +2010-09-30 Ivan Maidanski + + * darwin_stop_world.c (GC_query_task_threads): New variable (or + macro). + * darwin_stop_world.c (GC_push_all_stacks): Use + GC_query_task_threads (to choose between algorithms based on + kernel task_threads and based on GC_threads table); update FIXME; + remove commented out GC_push_one statements. + * pthread_support.c (GC_thr_init, GC_do_blocking_inner, + GC_call_with_gc_active, GC_register_my_thread_inner): Initialize + stack_ptr field for all platforms. + * pthread_support.c (GC_call_with_gc_active): Initialize + saved_stack_ptr field for all platforms. + * include/private/darwin_stop_world.h (thread_stop_info): Add + stack_ptr field; change type of already_suspended from int to + GC_bool. + +2010-09-29 Ivan Maidanski + + * darwin_stop_world.c (GC_MAX_MACH_THREADS): New macro. + * darwin_stop_world.c (GC_mach_threads, GC_stop_init): Use + GC_MAX_MACH_THREADS instead of THREAD_TABLE_SZ. + * darwin_stop_world.c (GC_mach_threads): Add FIXME. + * darwin_stop_world.c (GC_stop_init, GC_suspend_thread_list, + GC_stop_world): Use FALSE and TRUE for already_suspended field and + "changed", "found" variables. + * darwin_stop_world.c (GC_is_mach_marker): New prototype (only if + PARALLEL_MARK). + * darwin_stop_world.c (GC_suspend_thread_list): Change return type + to GC_bool; change type of "changed", "found" to GC_bool; make + "my_thread" as an argument (instead of acquiring/deallocating it + locally); do not add my_thread, GC_mach_handler_thread and marker + threads to GC_mach_threads table; check for overflow of + GC_mach_threads table; increase GC_mach_threads_count if "found" + is true and info.suspend_count is non-zero. + * darwin_stop_world.c (GC_suspend_thread_list, GC_start_world): + Adjust "thread" format specifiers for GC_printf(); search thread + in "old_list" starting from the previous found one. + * darwin_stop_world.c (GC_stop_world): Rename "changes" to + "changed" local variable; remove "result" variable; adjust + GC_printf debugging message. + * darwin_stop_world.c (GC_start_world): Do not check for + my_thread and GC_use_mach_handler_thread (since they are not added + to GC_mach_threads table); call thread_info() only if + DEBUG_THREADS or GC_ASSERTIONS. + * pthread_support.c (marker_mach_threads): New static variable (if + Darwin). + * pthread_support.c (GC_is_mach_marker): New function (if Darwin). + * pthread_support.c (GC_mark_thread): Fill in marker_mach_threads + table (if Darwin). + +2010-09-26 Ivan Maidanski + + * alloc.c (GC_parallel): Define only if THREADS. + * misc.c (GC_get_parallel): Ditto. + * include/gc.h (GC_parallel, GC_get_parallel, + GC_get_suspend_signal, GC_allow_register_threads, + GC_register_my_thread, GC_unregister_my_thread): Define only if + GC_THREADS. + * include/gc.h (GC_get_heap_size): Fix a typo in a comment. + +2010-09-11 Ivan Maidanski (really Ludovic Courtes) + + * configure.ac: Use `AC_C_INLINE'. + * include/private/gc_priv.h (GC_INLINE): Use "inline" keyword + (determined by configure AC_C_INLINE) if HAVE_CONFIG_H is defined. + * configure.ac: Expand all tabs to spaces. + * configure: Regenerate. + * include/private/config.h.in: Ditto. + +2010-09-11 Ivan Maidanski + + * dyn_load.c (DL_ITERATE_PHDR_STRONG): New macro (define for + FreeBSD). + * dyn_load.c (GC_register_main_static_data): Move the definition + above GC_register_dynamic_libraries_dl_iterate_phdr one (FreeBSD + case); unconditionally return FALSE if DL_ITERATE_PHDR_STRONG. + * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr): Test + GC_register_main_static_data() result (instead of direct testing + of dl_iterate_phdr (to prevent a compiler warning). + * os_dep.c (CODE_OK): Test si_code also for the value of 2 + (FreeBSD case; required for FreeBSD v7+). + * os_dep.c (CODE_OK): Properly use parentheses (HPUX case). + * include/private/gcconfig.h (DATASTART): Cast etext argument in + GC_FreeBSDGetDataStart() call; remove unnecessary "&" (FreeBSD + case). + +2010-09-09 Ivan Maidanski (with input from Ludovic Courtes) + + * include/private/specific.h (quick_thread_id): Define thru + GC_approx_sp(); define as a macro. + * include/private/specific.h (getspecific): Use GC_INLINE instead + of __inline__ (to work around Sun CC which does not recognize + inline keyword surrounded with underscores). + * include/private/specific.h: Expand all tabs to spaces; remove + trailing spaces at EOLn. + +2010-09-04 Ivan Maidanski + + * darwin_stop_world.c (FindTopOfStack): Simplify condition + expressions. + * darwin_stop_world.c (GC_push_all_stacks): Merge two variants + of this function (DARWIN_DONT_PARSE_STACK). + * darwin_stop_world.c (GC_push_all_stacks): Add a check for our + thread is found (same as in pthread_stop_world.c). + * darwin_stop_world.c (GC_push_all_stacks): Print the number of + scanned threads if verbose (same as in pthread_stop_world.c). + +2010-09-04 Ivan Maidanski + + * darwin_stop_world.c (GC_push_all_stacks): Reset + thread_state_count value before every thread_get_state call; + refine the comment for thread_state_count. + * darwin_stop_world.c (GC_push_all_stacks): Ignore rsp, rip/eip, + rflags, cs, fs, gs, ss, ds, es, __pc registers; uncomment ebp + register pushing. + * darwin_stop_world.c (GC_push_all_stacks): Set outCount to + GC_MACH_THREAD_STATE_COUNT (instead of THREAD_STATE_MAX). + * darwin_stop_world.c (GC_push_all_stacks): Remove FIXME and WARN + for i386. + +2010-09-03 Ivan Maidanski + + * doc/README.macros (DARWIN_DONT_PARSE_STACK): Fix a typo. + * darwin_stop_world.c (GC_use_mach_handler_thread): Change type + to GC_bool. + * darwin_stop_world.c (GC_suspend_thread_list, GC_start_world): + Simplify the expressions involving GC_use_mach_handler_thread. + * darwin_stop_world.c (GC_darwin_register_mach_handler_thread): + Initialize GC_use_mach_handler_thread to TRUE (instead of 1). + +2010-09-02 Ivan Maidanski + + * include/gc_pthread_redirects.h (GC_pthread_sigmask, GC_dlopen, + pthread_sigmask, dlopen): Don't define for Win32 pthreads (and + don't include signal.h and dlfcn.h). + +2010-08-25 Ivan Maidanski (with help from Hans Boehm) + + * dyn_load.c (GC_register_dynlib_callback): Add FIXME. + +2010-08-18 Ivan Maidanski (really Andreas Tobler) + + * include/private/gcconfig.h: Add support for FreeBSD on ppc64. + +2010-08-18 Ivan Maidanski (with help from Andreas Tobler) + + * os_dep.c (PROTECT, UNPROTECT): Correct VM_PROT_EXEC to + VM_PROT_EXECUTE. + +2010-08-14 Ivan Maidanski + + * aclocal.m4: Regenerate (by autoreconf -vif using autoconf-2.67, + automake-1.11.1 and libtool-2.2.8). + * configure: Ditto. + * ltmain.sh: Ditto. + * Makefile.in: Ditto. + * include/private/config.h.in: Ditto. + * m4/libtool.m4: Ditto. + * m4/ltoptions.m4: Ditto. + * m4/ltversion.m4: Ditto. + * m4/lt~obsolete.m4: Ditto. + +2010-08-14 Ivan Maidanski + + * os_dep.c (os2_alloc): Don't set PAG_EXECUTE unless + pages_executable is on. + * os_dep.c (os2_alloc): Add FIXME (for recursion). + * os_dep.c (UNPROTECT): Abort with a more informative message if + pages_executable is on ("mprotect" case). + * os_dep.c (PROTECT, UNPROTECT): Set VM_PROT_EXEC if + pages_executable is on (Darwin case). + * pthread_support.c (GC_init_real_syms): Abort with an informative + message if libgc is linked after libpthread. + +2010-08-14 Ivan Maidanski + + * dyn_load.c (GC_register_dynlib_callback): Adjust "start" pointer + for 64-bit targets. + * pthread_support.c (start_mark_threads): Expand PTHREAD_CREATE + macro. + * pthread_support.c (start_mark_threads): Call INIT_REAL_SYMS() + since REAL(pthread_create) is used. + * pthread_support.c (PTHREAD_CREATE): Remove unused. + +2010-08-14 Ivan Maidanski + + * extra/threadlibs.c (main): Remove --wrap for "read" (since not + wrapped anymore). + * doc/README.linux (GC_USE_LD_WRAP): Ditto. + * os_dep.c (__wrap_read): Ditto (in the comment). + +2010-08-14 Ivan Maidanski (with help from Hans Boehm) + + * include/gc_pthread_redirects.h: Test GC_PTHREADS and GC_H at the + beginning of the file. + * include/gc_pthread_redirects.h (GC_PTHREAD_EXIT_ATTRIBUTE): New + macro (defined only for Linux and Solaris). + * include/gc_pthread_redirects.h (GC_pthread_cancel, + GC_pthread_exit): Declare new API function (only if + GC_PTHREAD_EXIT_ATTRIBUTE). + * include/gc_pthread_redirects.h (pthread_cancel, pthread_exit): + Redirect (if GC_PTHREAD_EXIT_ATTRIBUTE). + * include/private/pthread_support.h (DISABLED_GC): New macro. + * pthread_support.c (pthread_cancel, pthread_exit): Restore + original definition or declare "real" function (if needed and + GC_PTHREAD_EXIT_ATTRIBUTE). + * pthread_support.c (GC_pthread_cancel_t, GC_pthread_exit_t): + Declare new types if needed. + * pthread_support.c (GC_pthread_cancel, GC_pthread_exit): New + function definition (only if GC_PTHREAD_EXIT_ATTRIBUTE). + * pthread_support.c (GC_init_real_syms): Initialize pointers to + the "real" pthread_cancel and pthread_exit (only if + GC_PTHREAD_EXIT_ATTRIBUTE). + * pthread_support.c (GC_unregister_my_thread): Enable collections + if DISABLED_GC was set (only if GC_PTHREAD_EXIT_ATTRIBUTE). + * pthread_support.c (pthread_cancel, pthread_exit): New wrapped + function definition (only if GC_PTHREAD_EXIT_ATTRIBUTE defined). + * pthread_support.c (GC_start_routine): Refine the comment. + * extra/threadlibs.c (main): Adjust --wrap (add "read", + "pthread_exit", "pthread_cancel" but remove "sleep"). + * doc/README.linux (GC_USE_LD_WRAP): Ditto. + * doc/README.linux: Expand all tabs to spaces; remove trailing + spaces at EOLn. + +2010-08-12 Ivan Maidanski (mostly really Mike Gran) + + * include/gc.h (GC_MALLOC_STUBBORN): Remove trailing ';' in the + macro definition. + * include/gc.h (GC_reachable_here): Ditto. + * include/gc.h (GC_reachable_here): Prefix and postfix "volatile" + with double '_'. + +2010-07-29 Ivan Maidanski (with input from NIIBE Yutaka) + + * pthread_start.c: New file. + * CMakeLists.txt (SRC): Add pthread_start.c. + * Makefile.am (libgc_la_SOURCES): Ditto. + * Makefile.direct (CSRCS): Ditto. + * Makefile.direct (OBJS): Add pthread_start.obj. + * extra/gc.c: Add a comment; include pthread_start.c. + * pthread_support.c (start_info): Move the struct definition down + closer to its usage. + * pthread_support.c (GC_thread_exit_proc): Replace STATIC with + GC_INNER. + * pthread_support.c (GC_inner_start_routine): Move to the + definition to pthread_start.c; leave only the prototype; remove + STATIC. + * pthread_support.c (GC_start_rtn_prepare_thread): New function + (contains parts of the original GC_inner_start_routine). + * Makefile.in: Regenerate. + * configure: Ditto. + +2010-07-28 Ivan Maidanski (mostly really Noah Lavine) + + * configure.ac (NO_EXECUTE_PERMISSION): Add comment. + * doc/README.macros (NO_EXECUTE_PERMISSION): Update the + documentation. + * include/gc.h (GC_set_pages_executable, GC_get_pages_executable): + New API function declaration. + * include/gc.h (GC_ignore_warn_proc): Reformat the comment. + * os_dep.c (OPT_PROT_EXEC): Remove (superseded by + pages_executable). + * os_dep.c (pages_executable): New static variable. + * os_dep.c (IGNORE_PAGES_EXECUTABLE): New macro (used by + GC_get_pages_executable only). + * os_dep.c (GC_unix_mmap_get_mem, GC_remap, PROTECT, UNPROTECT): + Replace OPT_PROT_EXEC with pages_executable. + * os_dep.c (GC_unix_mmap_get_mem, GC_remap, GC_win32_get_mem, + GC_wince_get_mem, UNPROTECT): Undefine IGNORE_PAGES_EXECUTABLE. + * os_dep.c (GC_win32_get_mem, GC_wince_get_mem, GC_remap, PROTECT, + UNPROTECT): Use PAGE_EXECUTE_... only if pages_executable is on. + * os_dep.c (GC_set_pages_executable, GC_get_pages_executable): New + API function definition. + +2010-07-28 Ivan Maidanski + + * tests/test.c (check_heap_stats): Increase max_heap_sz by 20% for + 64-bit CPUs (to prevent "Unexpected heap growth" failure on Win64, + at least). + +2010-07-14 Ivan Maidanski + + * tests/test.c (check_heap_stats): Increase max_heap_sz by 25% for + 32-bit CPUs (to prevent "Unexpected heap growth" failure). + +2010-07-13 Ivan Maidanski + + * gc_dlopen.c (dlopen): Prototype REAL_DLFUNC if GC_USE_LD_WRAP. + * pthread_support.c (pthread_create, pthread_join, pthread_detach, + pthread_sigmask): Ditto. + * gc_dlopen.c (dlopen): Remove cast (redundant since the prototype + is added). + * gc_dlopen.c (GC_dlopen): Fix return type. + * pthread_support.c (GC_init_real_syms): Don't define + LIBPTHREAD_NAME, LIBPTHREAD_NAME_LEN, len, namebuf and + libpthread_name if RTLD_NEXT. + +2010-07-13 Ivan Maidanski + + * gc_dlopen.c (disable_gc_for_dlopen): Update the comment. + * gc_dlopen.c (dlopen): Ditto. + * include/gc.h: Update copyright header. + * include/gc.h (GC_enable_incremental): Refine the comment. + * include/gc.h (DECLSPEC_NORETURN): Define macro as empty if + missing (only for Win32). + * include/gc.h (GC_ExitThread): Use DECLSPEC_NORETURN. + * win32_threads.c (GC_ExitThread): Ditto. + * include/gc.h (GC_endthreadex): Add a comment. + +2010-05-31 Ivan Maidanski (really Alexander Belchenko) + + * include/cord.h: Fix typos. + * include/cord.h: Expand all tabs to spaces; remove trailing + spaces at EOLn. + +2010-05-22 Ivan Maidanski + + * Makefile.in: Regenerate. + * configure: Ditto. + +2010-05-22 Ivan Maidanski + + * Makefile.am (EXTRA_DIST): Add "CMakeLists.txt" and + "tests/CMakeLists.txt". + * doc/doc.am (dist_pkgdata_DATA): Add "doc/README.cmake". + +2010-05-21 Ivan Maidanski (really Bradley Smith and + Stefano Rivera) + + * mach_dep.c (NO_GETCONTEXT): Also define if AVR32. + * include/private/gcconfig.h (AVR32): New macro (also define the + supplementary macros for the target). + * include/private/thread_local_alloc (USE_COMPILER_TLS): Don't + define for AVR32. + +2010-05-13 Ivan Maidanski (mostly really Uros Bizjak) + + * tests/leak_test.c (main): Explicitly define as returning int + (to prevent a spurious test failure on some Linux/alpha targets). + * tests/thread_leak_test.c (main): Ditto. + * tests/thread_leak_test.c: Initialize GC_find_leak in the main + thread (before GC_INIT) only. + * tests/leak_test.c (main): Use GC_set_find_leak() instead of + accessing GC_find_leak directly. + * tests/thread_leak_test.c (main): Ditto. + +2010-05-05 Ivan Maidanski + + * include/gc.h (GC_find_leak, GC_finalize_on_demand, + GC_java_finalization, GC_dont_expand, GC_no_dls, + GC_dont_precollect): Simplify the comment (remove the information + about data races since the value is boolean). + +2010-04-16 Ivan Maidanski (mostly really Louis Zhuang) + + * os_dep.c (GC_get_stack_base, GC_get_main_stack_base): New + Solaris-specific implementation (based on thr_stksegment). + * os_dep.c (stackbase_main_self, stackbase_main_ss_sp): New static + variable used by the Solaris-specific GC_get_stack_base(). + +2010-04-16 Ivan Maidanski (mostly really NIIBE Yutaka) + + * pthread_support.c (GC_mark_thread_local_free_lists, + GC_check_tls): Mark (and check) only for live threads (in case of + GC_destroy_thread_local() is called already but GC_delete_thread() + is not yet). + * win32_threads.c (GC_mark_thread_local_free_lists, GC_check_tls): + Ditto (matters only if GC_PTHREADS defined). + +2010-04-09 Ivan Maidanski + + * NT_MAKEFILE: Remove the comment about DLL and Win32S. + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Ditto. + * NT_MAKEFILE: Add ".SUFFIXES" directive (to handle gc_cpp.cc + properly on VS 2005+). + * NT_MAKEFILE: Update GC log file name in comments. + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_THREADS_MAKEFILE: Ditto. + * doc/README.win32: Ditto. + * NT_MAKEFILE: Remove ":full" for "-debug" option (since no + longer supported by VS). + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_MAKEFILE: Commented out copying of gc_cpp.cc to gc_cpp.cpp. + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_THREADS_MAKEFILE: Ditto. + * NT_STATIC_THREADS_MAKEFILE: Add -D PARALLEL_MARK option. + * NT_STATIC_THREADS_MAKEFILE: Increase stack size for gctest.exe. + * NT_X64_STATIC_THREADS_MAKEFILE: Remove "-stack" option (use the + default stack size limit). + * NT_X64_THREADS_MAKEFILE: Rename "gc64_dll.dll" to "gc64.dll". + * win32_threads.c (GC_get_next_stack): Always define (since it is + also used for Cygwin now). + +2010-03-26 Ivan Maidanski (really Hans Boehm) + + * alloc.c (GC_maybe_gc): Move GC_notify_full_gc() call upper to + be just before GC_clear_marks() call. + * include/gc_mark.h (GC_start_callback_proc): Refine the comment. + +2010-03-23 Ivan Maidanski (really Dave Korn) + + * Makefile.am (check_LTLIBRARIES): Initialize to empty. + * tests/tests.am (TESTS, check_PROGRAMS): Add staticrootstest. + * tests/tests.am (staticrootstest_SOURCES, staticrootstest_LDADD, + libstaticrootslib_la_SOURCES, libstaticrootslib_la_LIBADD, + libstaticrootslib_la_LDFLAGS, libstaticrootslib_la_DEPENDENCIES): + Define. + * tests/tests.am (check_LTLIBRARIES): Add libstaticrootslib.la. + * .cvsignore: Ignore libstaticrootslib.la. + * Makefile.in: Regenerate. + +2010-03-20 Ivan Maidanski + + * m4/libtool.m4: Re-add auto-generated file (for "make dist"). + * m4/lt~obsolete.m4: Ditto. + * m4/ltoptions.m4: Ditto. + * m4/ltsugar.m4: Ditto. + * m4/ltversion.m4: Ditto. + +2010-03-20 Ivan Maidanski (really Dave Korn) + + * tests/staticrootstest.c: New file. + * tests/staticrootslib.c: Ditto. + +2010-03-19 Ivan Maidanski (really Dave Korn) + + * dyn_load.c (GC_get_next_stack, GC_cond_add_roots): Define for + Cygwin as well as other win32 targets. + * dyn_load.c (GC_wnt): Define to constant true. + * dyn_load.c (GC_register_dynamic_libraries): Define for Cygwin as + well as other win32 targets. + * mark_rts.c (rt_hash, GC_roots_present, add_roots_to_index): + Don't define for Cygwin, as on other win32. + * mark_rts.c (GC_add_roots_inner, GC_clear_roots): Handle on + Cygwin as for other win32 targets. + * mark_rts.c (GC_rebuild_root_index): Don't declare on Cygwin, as + other win32. + * mark_rts.c (GC_remove_tmp_roots): Do declare on Cygwin as on + other win32. + * mark_rts.c (GC_remove_roots, GC_remove_roots_inner): Don't + declare on Cygwin as on other win32. + * mark_rts.c (GC_is_tmp_root): Do declare on Cygwin when + !NO_DEBUGGING, as on other win32 targets. + * mark_rts.c (GC_cond_register_dynamic_libraries): Handle on + Cygwin as for other win32 targets. + * os_dep.c (GC_setpagesize): Handle on Cygwin as on other win32. + * os_dep.c (GC_get_main_stack_base): Don't declare on Cygwin, as + other win32. + * os_dep.c (GC_sysinfo): Declare on Cygwin, as other win32. + * os_dep.c (GC_win32_get_mem): Declare on Cygwin, as on other + Win32, but call GC_unix_get_mem instead of GlobalAlloc. + * os_dep.c (GC_win32_free_heap): Declare on Cygwin (as empty). + * ptr_chck.c (GC_is_visible): Register dynamic libraries on Cygwin + as on other win32 platforms. + * win32_threads.c (GC_get_next_stack): Define on Cygwin as well as + for dynamic loading targets. + * include/private/gc_priv.h (GC_INNER): Don't try to use + visibility on Cygwin which does not support it. + * include/private/gc_priv.h (struct roots): Don't declare r_next + member on Cygwin as on other windows hosts. + * include/private/gc_priv.h (LOG_RT_SIZE, RT_SIZE): Don't define + likewise. + * include/private/gc_priv.h (struct _GC_arrays): Do declare + _heap_bases[] member and don't declare _root_index likewise. + * include/private/gc_priv.h (GC_heap_bases): Do define likewise. + * include/private/gc_priv.h (_SYSTEM_INFO): Do forward-declare + likewise. + * include/private/gc_priv.h (GC_sysinfo): Do declare extern + likewise. + * include/private/gcconfig.h (GC_win32_get_mem, GET_MEM): Do + prototype on Cygwin as other win32 platforms. + +2010-03-13 Ivan Maidanski + + * os_dep.c (GC_get_main_stack_base): Use pthread_getattr_np() and + pthread_attr_getstack() instead of GC_get_stack_base() (and check + returned stackaddr for NULL); output a warning on failure. + +2010-03-12 Ivan Maidanski + + * alloc.c (GC_start_call_back): Replace the definition type to + GC_start_callback_proc. + * alloc.c (GC_set_start_callback, GC_get_start_callback): New + setter/getter function. + * alloc.c (GC_try_to_collect_inner): Call GC_notify_full_gc() + unconditionally (because GC_try_to_collect_inner always does full + GC). + * include/gc_mark.h (GC_start_callback_proc): New type. + * include/gc_mark.h (GC_set_start_callback, + GC_get_start_callback): New API function declaration. + +2010-03-12 Ivan Maidanski + + * doc/README.macros (USE_GET_STACKBASE_FOR_MAIN): Document. + * os_dep.c (GC_get_main_stack_base): Recognize + USE_GET_STACKBASE_FOR_MAIN (only if THREADS and LINUX_STACKBOTTOM) + and use GC_get_stack_base() in this case. + +2010-03-05 Ivan Maidanski (really Burkhard Linke) + + * os_dep.c (GC_get_stack_base): Add LOCK/UNLOCK() (since + GC_find_limit_with_bound() should be called with the lock held). + * backgraph.c (FOR_EACH_PRED): Fix a typo. + +2010-03-05 Ivan Maidanski + + * alloc.c (GC_set_stop_func, GC_get_stop_func): Add + DCL_LOCK_STATE. + * finalize.c (GC_notify_or_invoke_finalizers): Ditto. + * gc_dlopen.c (disable_gc_for_dlopen): Ditto. + * gcj_mlc.c (maybe_finalize, GC_debug_gcj_malloc): Ditto. + * mark.c (GC_print_trace): Ditto. + * misc.c (GC_set_warn_proc, GC_get_warn_proc, GC_enable, + GC_disable, GC_new_free_list, GC_new_kind, GC_new_proc, + GC_set_oom_fn, GC_get_oom_fn, GC_set_finalizer_notifier, + GC_get_finalizer_notifier): Ditto. + * os_dep.c (GC_get_stack_base, GC_print_callers): Ditto. + * pthread_support.c (GC_is_thread_tsd_valid, + GC_wait_for_gc_completion, GC_init_parallel, GC_do_blocking_inner, + GC_call_with_gc_active, GC_unregister_my_thread, pthread_join, + pthread_detach, GC_register_my_thread, GC_inner_start_routine, + pthread_create): Ditto. + * reclaim.c (GC_print_all_errors): Ditto. + * win32_threads.c (GC_is_thread_tsd_valid, GC_register_my_thread, + GC_unregister_my_thread, GC_do_blocking_inner, + GC_call_with_gc_active, GC_lookup_pthread, GC_pthread_join, + GC_pthread_start_inner, GC_thread_exit_proc, GC_pthread_detach, + GC_init_parallel): Ditto. + +2010-02-25 Ivan Maidanski (really Bruce Mitchener) + + * .cvsignore: New file. + * include/private/.cvsignore: Ditto. + +2010-02-24 Ivan Maidanski + + * CMakeLists.txt: Change copyright header. + * tests/CMakeLists.txt: Ditto. + +2010-02-24 Ivan Maidanski (really Bruce Mitchener) + + * doc/README.darwin: Update. + +2010-02-24 Ivan Maidanski (really Bruce Mitchener) + + * CMakeLists.txt: Adjust INCLUDE_DIRECTORIES and SRC (to make it + usable on Mac OS X). + * doc/README.cmake: Update. + +2010-02-24 Ivan Maidanski (really Jack Andrews) + + * CMakeLists.txt: New file (adding CMake support). + * tests/CMakeLists.txt: Ditto. + * doc/README.cmake: Ditto. + +2010-02-19 Ivan Maidanski (really Bruce Mitchener) + + * configure.ac (darwin): Don't define HAS_PPC_THREAD_STATE... + macros. + * include/private/gc_priv.h (THREAD_FLD): Recognize + __DARWIN_UNIX03 instead of HAS_PPC_THREAD_STATE... macros. + * configure: Regenerate. + * include/private/config.h.in: Ditto. + +2010-02-15 Ivan Maidanski (really Alexandr Shadchin) + + * pthread_support.c: Include and for + OpenBSD. + * pthread_support.c (get_ncpu): Define also for Darwin, NetBSD and + OpenBSD. + * pthread_support.c (GC_thr_init): Use get_ncpu() for Darwin, + NetBSD and OpenBSD. + +2010-02-04 Ivan Maidanski + + * mallocx.c (GC_generic_malloc_many, GC_malloc_many): Define even + if THREADS is undefined. + * include/gc.h (GC_malloc_many): Update the comment. + +2010-02-03 Ivan Maidanski + + * ChangeLog: Fix some typos. + +2010-01-29 Ivan Maidanski + + * Makefile.in: Regenerate (by autoreconf -vif using + libtool-2.2.6b, automake-1.11.1, autoconf-2.65). + * aclocal.m4: Ditto. + * compile: Ditto. + * config.guess: Ditto. + * config.sub: Ditto. + * configure: Ditto. + * depcomp: Ditto. + * install-sh: Ditto. + * ltmain.sh: Ditto. + * missing: Ditto. + * mkinstalldirs: Ditto. + +2010-01-15 Ivan Maidanski + + * include/gc_cpp.h (GC_PLACEMENT_DELETE): Define for Embarcadero + (formerly known as Borland) C++ compiler v6.21+. + * include/gc_cpp.h (GC_NO_OPERATOR_NEW_ARRAY): Define for ancient + VC++ compilers. + +2009-12-18 Ivan Maidanski + + * win32_threads.c (GC_register_my_thread_inner, + GC_pthread_start_inner): Undo the previous commit changes for + the thread flags and DETACHED state (since the state is only + tested in GC_thread_exit_proc). + +2009-12-18 Ivan Maidanski (with input from + Jean-Claude Beaudoin) + + * include/gc.h (GC_unregister_my_thread): Fix a typo; update the + comment. + * pthread_support.c (GC_delete_thread): Allow to delete the main + thread (don't call GC_INTERNAL_FREE for it); update the comment. + * win32_threads.c (GC_delete_thread): Ditto. + * pthread_support.c (GC_unregister_my_thread): Add an assertion + for FINISHED flag is unset. + * tests/test.c (check_heap_stats): Test the main thread + unregistering (only if THREADS). + * win32_threads.c (GC_register_my_thread_inner): Set flags to + DETACHED (only if GC_PTHREADS). + * win32_threads.c (GC_unregister_my_thread): Add FIXME (for + GC_wait_for_gc_completion). + * win32_threads.c (GC_pthread_start_inner): Clear flags detached + state if needed; set pthread_id and flags while holding the lock. + +2009-12-17 Ivan Maidanski (with input from Andy Wingo) + + * include/private/gc_priv.h (SIG_SUSPEND): Don't define for + OpenBSD and Darwin. + +2009-12-17 Ivan Maidanski + + * include/gc.h: Recognize _M_X64 (as an alias for _AMD64_). + +2009-12-10 Hans-J. Boehm + + * test.c (main, WinMain): Consistently don't invoke + GC_enable_incremental() if MAKE_BACKGRAPH is defined, but + do invoke it even if parallel marking is enabled. + +2009-12-08 Ivan Maidanski + + * tests/test.c (reverse_test): Comment out a check for MSWIN32 + (when determing BIG value) assuming outdated win32S. + * tests/test.c (reverse_test): Rename to reverse_test_inner; + change the declaration (to be of GC_fn_type); call itself thru + GC_call_with_gc_active() if the argument is zero. + * tests/test.c (reverse_test): New function added calling + reverse_test_inner thru GC_do_blocking (to test GC_do_blocking and + GC_call_with_gc_active). + +2009-12-08 Ivan Maidanski (with input from Marcos Dione) + + * doc/README.macros (IGNORE_DYNAMIC_LOADING, PLATFORM_ANDROID): + Document. + * dyn_load.c: Don't include if PLATFORM_ANDROID. + * dyn_load.c: Include bionic (instead of ) if + PLATFORM_ANDROID. + * include/private/gcconfig.h (LINUX): Define also if + PLATFORM_ANDROID (for the windows-based toolkit). + * include/private/gcconfig.h (SEARCH_FOR_DATA_START): Explicitly + define for Android/x86 platform. + * include/private/gcconfig.h (IGNORE_DYNAMIC_LOADING): Recognize + new macro (undefine DYNAMIC_LOADING in this case). + * include/private/gcconfig.h (CANCEL_SAFE): Don't define if + PLATFORM_ANDROID. + * include/private/gcconfig.h (IF_CANCEL): Fix definition for the + explicitly defined CANCEL_SAFE. + +2009-12-08 Ivan Maidanski + + * allchblk.c (GC_allochblk_nth): Don't call GC_remove_protection() + if GC_DISABLE_INCREMENTAL. + * reclaim.c (GC_reclaim_generic): Ditto. + * checksums.c (GC_page_was_ever_dirty): Add prototype. + * include/private/gc_locks.h (GC_mark_lock_holder): Don't declare + unless PARALLEL_MARK. + * include/private/gc_priv.h (GC_dirty_maintained, + GC_page_was_dirty, GC_remove_protection, GC_dirty_init): Don't + declare if GC_DISABLE_INCREMENTAL. + * include/private/gc_priv.h (GC_print_finalization_stats): Don't + declare if SMALL_CONFIG. + * include/private/gcconfig.h (CHECKSUMS): Explicitly undefine if + GC_DISABLE_INCREMENTAL (since nothing to check). + * include/private/gcconfig.h (DEFAULT_VDB): Don't define if + GC_DISABLE_INCREMENTAL. + * os_dep.c (GC_dirty_maintained): Ditto. + * mark.c (GC_initiate_gc): Don't call GC_read_dirty() if + GC_DISABLE_INCREMENTAL. + * os_dep.c (GC_gww_page_was_ever_dirty, GC_page_was_ever_dirty): + Uncomment; define only if CHECKSUMS. + +2009-12-08 Ivan Maidanski + + * darwin_stop_world.c (GC_push_all_stacks): Fix a bug (call + GC_push_all_stack() instead of GC_push_all_stack_frames()). + * include/private/gc_priv.h (GC_push_all_stack_frames, + GC_push_all_register_frames): Rename to + GC_push_all_stack_sections and GC_push_all_register_sections, + respectively. + * mark_rts.c (GC_push_all_stack_frames, + GC_push_all_register_frames, GC_push_all_stack_part_eager_frames, + GC_push_current_stack): Ditto. + * pthread_stop_world.c (GC_push_all_stacks): Ditto. + * win32_threads.c (GC_push_stack_for): Ditto. + * misc.c (GC_call_with_gc_active): Rename "frame" local variable + to "stacksect". + * pthread_support.c (GC_call_with_gc_active): Ditto. + * win32_threads.c (GC_call_with_gc_active): Ditto. + * pthread_support.c (GC_call_with_gc_active): Update FIXME for + Darwin. + * win32_threads.c (GC_Thread_Rep): Update the comment for + traced_stack_sect. + +2009-12-08 Ivan Maidanski (really mostly Hans Boehm) + + * darwin_stop_world.c (GC_push_all_stacks): Rename + activation_frame to traced_stack_sect. + * include/private/gc_priv.h (GC_push_all_stack_frames, + GC_push_all_register_frames): Ditto. + * include/private/pthread_support.h (GC_Thread_Rep): Ditto. + * mark_rts.c (GC_push_all_register_frames, + GC_push_all_stack_frames, GC_push_all_stack_part_eager_frames, + GC_push_current_stack): Ditto. + * pthread_stop_world.c (GC_push_all_stacks): Ditto. + * pthread_support.c (GC_call_with_gc_active): Ditto. + * win32_threads.c (GC_Thread_Rep, GC_call_with_gc_active, + GC_push_stack_for): Ditto. + * include/private/gc_priv.h (GC_activation_frame_s): Rename to + GC_traced_stack_sect_s. + * include/private/gc_priv.h (GC_activation_frame): Rename to + GC_traced_stack_sect. + * misc.c (GC_activation_frame, GC_call_with_gc_active): Ditto. + * doc/README.macros (UNICODE): Document. + +2009-12-07 Ivan Maidanski + + * doc/README.macros (GC_READ_ENV_FILE): Document (new macro). + * include/private/gc_priv.h (GETENV): Recognize GC_READ_ENV_FILE; + declare and use GC_envfile_getenv(). + * misc.c (GC_envfile_content, GC_envfile_length): New static + variable (only if GC_READ_ENV_FILE). + * misc.c (GC_ENVFILE_MAXLEN): New macro (used in GC_envfile_init). + * misc.c (GC_envfile_init, GC_envfile_getenv): New function (only + if GC_READ_ENV_FILE). + * misc.c (GC_init): Call GC_envfile_init() (before using GETENV) + if GC_READ_ENV_FILE. + * misc.c (GC_init): Move GC_setpagesize() and GC_init_win32() + calls to be just before GC_envfile_init() one (since the latter + uses GET_MEM). + * misc.c (GC_abort): use ExitProcess() (instead of DebugBreak) for + WinCE if NO_DEBUGGING; add a comment for DebugBreak() (for WinCE). + * mark_rts.c (GC_add_roots_inner): Remove redundant trailing '\n' + from the ABORT message. + * misc.c (GC_init): Ditto. + * os_dep.c (GC_get_main_stack_base, GC_register_data_segments): + Ditto. + * pthread_stop_world.c (GC_push_all_stacks): Ditto. + * pthread_support.c (GC_init_real_syms, start_mark_threads): + Ditto. + +2009-12-06 Ivan Maidanski + + * win32_threads.c (GC_get_next_stack): Don't define for Cygwin + (since unused for now). + +2009-12-06 Ivan Maidanski + + * dyn_load.c (HAVE_REGISTER_MAIN_STATIC_DATA): Don't define unless + GC_register_main_static_data() is defined. + * dyn_load.c (GC_register_dynamic_libraries): Define only if used + (if DYNAMIC_LOADING or PCR or Win32/CE). + * dyn_load.c (GC_register_main_static_data): Define the default + one only if DYNAMIC_LOADING. + * include/private/gc_priv.h (GC_register_dynamic_libraries): + Declare only if used (to prevent compiler warning). + +2009-12-04 Ivan Maidanski + + * mark_rts.c (GC_approx_sp): Add a comment (for GCC). + +2009-12-04 Ivan Maidanski + + * include/gc_version.h, configure.ac, doc/README: Change to + version 7.2alpha5. + * configure: Regenerate. + +[7.2alpha4] + +2009-12-01 Ivan Maidanski + + * include/gc_version.h, configure.ac, doc/README: Change to + version 7.2alpha4. + * configure: Regenerate. + +2009-11-21 Ivan Maidanski + + * configure.ac (AC_CONFIG_COMMANDS): Quote srcdir value. + * configure: Regenerate. + +2009-11-18 Ivan Maidanski (really mostly Zoltan Varga) + + * include/gc.h (GC_get_suspend_signal): New function declaration. + * misc.c (GC_get_suspend_signal): New API function (only if + THREADS). + +2009-11-16 Ivan Maidanski + + * alloc.c (min_bytes_allocd): Multiply GC_free_space_divisor by + two if GC_incremental (instead of TRUE_INCREMENTAL). + +2009-11-10 Ivan Maidanski + + * sparc_mach_dep.S (GC_push_regs): Remove the reference. + +2009-11-09 Ivan Maidanski + + * os_dep.c (SIZE_T, PULONG_PTR): Remove. + * os_dep.c (ULONG_PTR): Replace with GC_ULONG_PTR (defined as GC + "word"); add the comment. + * os_dep.c (GetWriteWatch_type, detect_GetWriteWatch, + GC_gww_read_dirty): Prefix ULONG_PTR with "GC_". + +2009-11-07 Ivan Maidanski + + * win32_threads.c (THREAD_TABLE_SZ): Change back to a power-of-two + const value (for speed). + * win32_threads.c (THREAD_TABLE_INDEX): New macro. + * win32_threads.c (GC_new_thread, GC_lookup_thread_inner, + GC_delete_gc_thread, GC_delete_thread, GC_lookup_pthread): Use + THREAD_TABLE_INDEX instead of THREAD_TABLE_SZ. + * win32_threads.c (PTHREAD_MAP_HASH): Rename to PTHREAD_MAP_INDEX. + +2009-11-07 Ivan Maidanski + + * win32_threads.c (THREAD_TABLE_SZ): Make the const value prime. + +2009-11-06 Ivan Maidanski + + * backgraph.c: Remove apostrophe char from "#error". + +2009-11-06 Ivan Maidanski + + * doc/README.macros (GC_DISABLE_INCREMENTAL): Document. + * include/private/gcconfig.h (GC_DISABLE_INCREMENTAL): Recognize + new macro; implicitly define it if SMALL_CONFIG. + * alloc.c (GC_incremental, GC_timeout_stop_func): Check for + GC_DISABLE_INCREMENTAL instead of SMALL_CONFIG. + * include/private/gc_priv.h (GC_incremental, TRUE_INCREMENTAL, + GC_push_conditional): Ditto. + * mark.c (GC_push_next_marked_dirty, GC_push_selected, + GC_push_conditional, GC_block_was_dirty): Ditto. + * misc.c (GC_enable_incremental): Ditto. + * misc.c (GC_init): Ditto (for "GC_PAUSE_TIME_TARGET" and + "GC_ENABLE_INCREMENTAL" environment variables). + * misc.c (GC_enable_incremental): Reformat the code. + +2009-11-06 Ivan Maidanski + + * dyn_load.c (WIN32_LEAN_AND_MEAN): Guard with ifndef. + * misc.c (WIN32_LEAN_AND_MEAN): Ditto. + * os_dep.c (WIN32_LEAN_AND_MEAN): Ditto. + * allchblk.c (GC_allochblk_nth): Fix a minor typo (don't/doesn't) + in a comment. + * backgraph.c: Ditto. + * dyn_load.c (GC_register_dynamic_libraries): Ditto. + * extra/threadlibs.c (main): Ditto. + * pthread_support.c (pthread_join): Ditto. + * tests/test.c (main): Ditto. + +2009-11-06 Ivan Maidanski + + * mach_dep.c (GC_push_regs): Remove STATIC (just to catch + a duplicate symbol definition linker error). + * misc.c (GC_clear_stack_inner): Ditto. + * sparc_mach_dep.S (GC_push_regs): Comment out the reference. + * sparc_mach_dep.S: Remove trailing spaces at EOLn; remove + multiple trailing blank lines. + +2009-11-06 Ivan Maidanski + + * include/private/gc_priv.h (GC_write_disabled): New variable + declaration (only if GC_ASSERTIONS and Win32 threads). + * misc.c (GC_write): Add assertion for GC_write_disabled value is + not on (only if THREADS). + * win32_threads.c (GC_write_disabled): New variable (only if + GC_ASSERTIONS and not Cygwin). + * win32_threads.c (GC_stop_world): Set and clear GC_write_disabled + (while holding GC_write_cs). + +2009-11-05 Ivan Maidanski + + * win32_threads.c (GC_please_stop): If DllMain-based thread + registration is not compiled in then define GC_please_stop as + a non-volatile variable for assertion only. + * win32_threads.c (GC_stop_world): Set and clear only if defined. + * win32_threads.c (GC_stop_world): Add the comment for GC_printf() + usage (while holding GC_write_cs). + * win32_threads.c (GC_delete_gc_thread): Ditto. + * os_dep.c (GC_remove_protection): Ditto. + +2009-11-05 Ivan Maidanski + + * pthread_support.c (GC_inner_start_routine): Join 3 sequential + GC_printf() calls into a single one (for DEBUG_THREADS). + +2009-11-05 Ivan Maidanski + + * include/private/gc_priv.h (GC_total_stacksize): New variable + declaration (only if THREADS). + * alloc.c (GC_total_stacksize): New variable (only if THREADS). + * alloc.c (min_bytes_allocd): Calculate stack_size using + GC_stackbottom only in the single-threaded case; otherwise use + GC_total_stacksize; print GC_total_stacksize value if + DEBUG_THREADS. + * darwin_stop_world.c (GC_push_all_stacks): Use "%p" printf type + specifier for lo/hi values (instead of "%lx"). + * darwin_stop_world.c (GC_push_all_stacks): Use + GC_push_all_stack_frames() instead of GC_push_all_stack(). + * darwin_stop_world.c (GC_push_all_stacks): Recalculate + GC_total_stacksize value. + * pthread_stop_world.c (GC_push_all_stacks): Ditto. + * win32_threads.c (GC_push_all_stacks): Ditto. + * win32_threads.c (GC_push_stack_for): Pass "me" argument; return + stack size; don't check for non-zero value of thread->stack_base. + * win32_threads.c (GC_push_all_stacks): Don't call + GC_push_stack_for() and don't check for "t->id == me" if + thread->stack_base is zero. + +2009-11-05 Ivan Maidanski + + * dyn_load.c (GC_dump_meminfo): Prefix "%lx" printf type specifier + with "0x". + * os_dep.c (PROTECT): Ditto. + * win32_threads.c (GC_mark_thread_local_free_lists): Cast p->id to + int (to match printf type specifier). + +2009-11-05 Ivan Maidanski + + * tests/test.c (check_heap_stats): Take into account the unmapped + memory size when checking for "Unexpected heap growth"; remove + FIXME. + +2009-11-03 Hans Boehm + + * alloc.c: Revert last change. + +2009-11-02 Ivan Maidanski + + * include/private/gcconfig.h (STACKBOTTOM): Add a presence check + for eCos/NOSYS. + * misc.c (GC_write): Comment out _Jv_diag_write() call (since no + longer defined in GCJ). + +2009-11-02 Ivan Maidanski + + * os_dep.c (brk): Rename to ecos_gc_brk. + +2009-11-01 Ivan Maidanski + + * alloc.c (min_bytes_allocd): Use GC_stackbottom value to compute + stack_size even if THREADS. + * doc/README.macros (DEBUG_THREADS): Document. + * pthread_support.c (DEBUG_THREADS): Remove the commented out + definition. + * win32_threads.c (DEBUG_WIN32_THREADS): Remove duplicate + definition. + * win32_threads.c: Include errno.h (except for WinCE). + * win32_threads.c (GC_win32_start_inner): Copy "start" and "param" + to local variables, and free "arg" parameter before "start" + invocation. + * win32_threads.c (GC_beginthreadex): Set errno to EAGAIN on error + (instead of calling SetLastError(ERROR_NOT_ENOUGH_MEMORY)). + * win32_threads.c (GC_beginthreadex): Return 0 on error (instead + of -1). + +2009-10-23 Ivan Maidanski + + * darwin_stop_world.c (GC_darwin_register_mach_handler_thread): + Use GC_INNER for the function definition. + * include/private/darwin_stop_world.h + (GC_darwin_register_mach_handler_thread): Remove the prototype. + * include/private/darwin_stop_world.h: Add copyright header. + * os_dep.c (GC_darwin_register_mach_handler_thread): Use GC_INNER + for the function prototype. + * include/private/gc_priv.h (NDEBUG): Explicitly define if + NO_DEBUGGING and not GC_ASSERTIONS (before the standard headers + inclusion). + +2009-10-22 Ivan Maidanski + + * include/private/gcconfig.h: Move DebugBreak() workaround (for + x86mingw32ce toolchain) to gc_priv.h (after windows.h inclusion). + +2009-10-22 Ivan Maidanski + + * allchblk.c (GC_unmap_old, GC_merge_unmapped, GC_allochblk, + GC_freehblk): Use GC_INNER for the function definition. + * alloc.c (GC_never_stop_func, GC_should_collect, + GC_try_to_collect_inner, GC_collect_a_little_inner, + GC_set_fl_marks, GC_add_to_our_memory, GC_add_to_heap, + GC_expand_hp_inner, GC_collect_or_expand, GC_allocobj): Ditto. + * backgraph.c (GC_build_back_graph, GC_traverse_back_graph): + Ditto. + * blacklst.c (GC_default_print_heap_obj_proc, GC_bl_init, + GC_promote_black_lists, GC_unpromote_black_lists, + GC_add_to_black_list_normal, GC_add_to_black_list_stack, + GC_is_black_listed): Ditto. + * darwin_stop_world.c (GC_push_all_stacks, GC_push_all_stacks, + GC_stop_init, GC_stop_world, GC_start_world): Ditto. + * dbg_mlc.c (GC_has_other_debug_info, GC_store_back_pointer, + GC_marked_for_finalization, GC_generate_random_backtrace_no_gc, + GC_store_debug_info, GC_start_debugging, + GC_debug_generic_malloc_inner, + GC_debug_generic_malloc_inner_ignore_off_page, + GC_debug_malloc_uncollectable, GC_debug_free_inner): Ditto. + * dyn_load.c (GC_register_dynamic_libraries, + GC_register_main_static_data, GC_init_dyld): Ditto. + * finalize.c (GC_push_finalizer_structures, GC_finalize, + GC_notify_or_invoke_finalizers, GC_print_finalization_stats): + Ditto. + * gcj_mlc.c (GC_core_gcj_malloc): Ditto. + * headers.c (GC_find_header, GC_header_cache_miss, + GC_scratch_alloc, GC_init_headers, GC_install_header, + GC_install_counts, GC_remove_header, GC_remove_counts, + GC_next_used_block, GC_prev_block): Ditto. + * mach_dep.c (GC_with_callee_saves_pushed): Ditto. + * malloc.c (GC_collect_or_expand, GC_alloc_large, + GC_generic_malloc_inner, GC_generic_malloc_inner_ignore_off_page, + GC_core_malloc_atomic, GC_core_malloc, GC_free_inner): Ditto. + * mallocx.c (GC_generic_malloc_ignore_off_page): Ditto. + * mark.c (GC_collection_in_progress, GC_clear_hdr_marks, + GC_set_hdr_marks, GC_set_mark_bit, GC_clear_mark_bit, + GC_clear_marks, GC_initiate_gc, GC_mark_some, + GC_mark_stack_empty, GC_invalidate_mark_state, + GC_signal_mark_stack_overflow, GC_mark_from, GC_help_marker, + GC_mark_init, GC_push_all, GC_push_conditional, + GC_mark_and_push_stack, GC_push_all_eager, GC_push_all_stack): + Ditto. + * mark_rts.c (GC_is_static_root, GC_roots_present, GC_approx_sp, + GC_exclude_static_roots_inner, GC_push_all_register_frames, + GC_push_all_stack_frames, GC_cond_register_dynamic_libraries, + GC_push_roots): Ditto. + * misc.c (GC_extend_size_map, GC_clear_stack, GC_err_write): + Ditto. + * new_hblk.c (GC_build_fl, GC_new_hblk): Ditto. + * obj_map.c (GC_register_displacement_inner, GC_add_map_entry, + GC_initialize_offsets): Ditto. + * os_dep.c (GC_get_maps, GC_parse_map_entry, GC_text_mapping, + GC_init_linux_data_start, GC_init_netbsd_elf, GC_setpagesize, + GC_set_and_save_fault_handler, GC_setup_temporary_fault_handler, + GC_reset_fault_handler, GC_get_register_stack_base, GC_init_win32, + GC_add_current_malloc_heap, GC_is_heap_base, GC_unmap, GC_remap, + GC_unmap_gap, GC_push_all_stacks, GC_gww_dirty_init, + GC_dirty_init, GC_read_dirty, GC_page_was_dirty, + GC_page_was_ever_dirty, GC_remove_protection, + GC_write_fault_handler, GC_mprotect_stop, GC_mprotect_resume, + GC_save_callers, GC_print_callers): Ditto. + * pthread_stop_world.c (GC_push_all_stacks, GC_stop_world, + GC_start_world, GC_stop_init): Ditto. + * pthread_support.c (GC_mark_thread_local_free_lists, + GC_lookup_thread, GC_reset_finalizer_nested, + GC_check_finalizer_nested, GC_segment_is_thread_stack, + GC_greatest_stack_base_below, GC_thr_init, GC_init_parallel, + GC_do_blocking_inner, GC_lock, GC_acquire_mark_lock, + GC_release_mark_lock, GC_wait_for_reclaim, GC_notify_all_builder, + GC_wait_marker, GC_notify_all_marker): Ditto. + * reclaim.c (GC_print_all_errors, GC_block_empty, + GC_reclaim_generic, GC_start_reclaim, GC_continue_reclaim, + GC_reclaim_all): Ditto. + * thread_local_alloc.c (GC_init_thread_local, + GC_destroy_thread_local, GC_mark_thread_local_fls_for): Ditto. + * win32_threads.c (GC_reset_finalizer_nested, + GC_check_finalizer_nested, GC_do_blocking_inner, GC_stop_world, + GC_start_world, GC_push_all_stacks, GC_get_next_stack, + GC_acquire_mark_lock, GC_release_mark_lock, GC_wait_for_reclaim, + GC_notify_all_builder, GC_wait_marker, GC_notify_all_marker, + GC_thr_init, GC_init_parallel, GC_lock, + GC_mark_thread_local_free_lists): Ditto. + * alloc.c (GC_add_current_malloc_heap, GC_build_back_graph, + GC_traverse_back_graph): Use GC_INNER for the function prototype. + * darwin_stop_world.c (GC_mprotect_stop, GC_mprotect_resume): + Ditto. + * dbg_mlc.c (GC_default_print_heap_obj_proc): Ditto. + * dyn_load.c (GC_parse_map_entry, GC_get_maps, + GC_segment_is_thread_stack, GC_roots_present, GC_is_heap_base, + GC_get_next_stack): Ditto. + * finalize.c (GC_reset_finalizer_nested, + GC_check_finalizer_nested): Ditto. + * gcj_mlc.c (GC_start_debugging): Ditto. + * include/private/dbg_mlc.h (GC_save_callers, GC_print_callers, + GC_has_other_debug_info, GC_store_debug_info): Ditto. + * include/private/gc_hdrs.h (GC_header_cache_miss): Ditto. + * include/private/gc_locks.h (GC_lock): Ditto. + * include/private/gc_pmark.h (GC_signal_mark_stack_overflow, + GC_mark_from): Ditto. + * include/private/pthread_support.h (GC_lookup_thread, + GC_stop_init): Ditto. + * include/private/thread_local_alloc.h (GC_init_thread_local, + GC_destroy_thread_local, GC_mark_thread_local_fls_for): Ditto. + * malloc.c (GC_extend_size_map, GC_text_mapping): Ditto. + * mark.c (GC_page_was_ever_dirty): Ditto. + * mark_rts.c (GC_mark_thread_local_free_lists): Ditto. + * misc.c (GC_register_main_static_data, GC_init_win32, + GC_setpagesize, GC_init_linux_data_start, + GC_set_and_save_fault_handler, GC_init_dyld, GC_init_netbsd_elf, + GC_do_blocking_inner): Ditto. + * os_dep.c (GC_greatest_stack_base_below): Ditto. + * win32_threads.c (GC_write_fault_handler, GC_gww_dirty_init): + Ditto. + * include/private/gc_priv.h: Ditto (for most prototypes). + * include/private/gc_priv.h (GC_INNER): Update the comment. + * doc/README.macros (GC_DLL): Update. + +2009-10-22 Ivan Maidanski + + * alloc.c (GC_collection_in_progress): Move the prototype to + gc_priv.h. + * gc_dlopen.c (GC_collection_in_progress): Ditto. + * pthread_support.c (GC_collection_in_progress): Ditto. + * misc.c (GC_init_parallel): Ditto. + * pthread_support.c (GC_init_parallel): Ditto. + * win32_threads.c (GC_init_parallel): Ditto. + * darwin_stop_world.c (GC_thr_init): Ditto. + * misc.c (GC_thr_init): Ditto. + * pthread_stop_world.c (GC_thr_init): Ditto. + * pthread_support.c (GC_thr_init): Ditto. + * blacklst.c (GC_clear_bl, GC_copy_bl, + GC_number_stack_black_listed): Make STATIC. + * dbg_mlc.c (GC_print_obj, GC_make_closure, + GC_debug_invoke_finalizer): Ditto. + * malloc.c (GC_alloc_large_and_clear): Ditto. + * mark.c (GC_push_selected, GC_push_marked1, GC_push_marked2, + GC_push_marked4, GC_push_marked, GC_push_next_marked, + GC_push_next_marked_dirty, GC_push_next_marked_uncollectable): + Ditto. + * misc.c (GC_clear_stack_inner): Ditto. + * os_dep.c (GC_repeat_read, GC_default_push_other_roots): Ditto. + * darwin_stop_world.c (FindTopOfStack): Make static; define only + if not DARWIN_DONT_PARSE_STACK. + * dbg_mlc.c (GC_debug_free_inner): Define only if DBG_HDRS_ALL. + * dyn_load.c (GC_repeat_read): Remove unused prototype. + * include/private/gc_pmark.h (GC_find_start): Ditto. + * misc.c (GC_read, GC_register_finalizer_no_order): Ditto. + * dyn_load.c (GC_segment_is_thread_stack): Add prototype (only if + THREADS). + * dyn_load.c (GC_register_main_static_data): Define only if + DYNAMIC_LOADING. + * finalize.c (GC_enqueue_all_finalizers): Remove unnecessary tail + "return" statement. + * gc_dlopen.c (GC_SOLARIS_THREADS): Don't recognize (since implies + GC_PTHREADS). + * include/gc.h: Fix a typo. + * include/gc_inline.h (GC_ASSERT): Define (if not defined) since + the header is public. + * include/gc_inline.h (GC_generic_malloc_many): New public + function declaration. + * mallocx.c (GC_generic_malloc_many): Make public. + * include/private/gc_priv.h (GC_INNER): Use visibility attribute + (if available). + * include/private/gc_priv.h (GC_EXTERN): Define using GC_INNER. + * include/private/gc_priv.h: Include atomic_ops.h if THREADS and + MPROTECT_VDB. + * os_dep.c: Don't include atomic_ops.h + * win32_threads.c: Ditto. + * include/private/gc_priv.h (GC_push_selected, GC_push_regs, + GC_push_marked, GC_number_stack_black_listed, + GC_alloc_large_and_clear, GC_reclaim_or_delete_all, + GC_generic_malloc_many, GC_make_closure, + GC_debug_invoke_finalizer, GC_print_obj, GC_page_was_ever_dirty): + Remove the prototype. + * mark.c (GC_page_was_ever_dirty): Add prototype (only if + PROC_VDB). + * include/private/gc_priv.h (GC_push_next_marked_dirty, + GC_push_next_marked, GC_push_next_marked_uncollectable): Move + the prototype to mark.c. + * include/private/gc_priv.h (GC_is_static_root): Declare only if + not THREADS. + * include/private/gc_priv.h (GC_free_inner): Declare only if + THREADS. + * include/private/gc_priv.h (GC_debug_free_inner): Declare only if + THREADS and DBG_HDRS_ALL. + * include/private/gc_priv.h (GC_markers): Declare GC_markers only + if PARALLEL_MARK. + * include/private/gc_priv.h (GC_register_main_static_data): Move + the prototype to misc.c. + * mach_dep.c (GC_push_regs): Make STATIC; define only along with + HAVE_PUSH_REGS definition. + * mach_dep.c (GC_clear_stack_inner): Replace K&R-style function + definition with the ANSI C one. + * mark.c (GC_started_thread_while_stopped): Declared only if not + GNU C. + * win32_threads.c (GC_started_thread_while_stopped): Don't define + if GNU C. + * mark.c (GC_mark_from): Avoid unbalanced brackets in + #if-#else-#endif blocks. + * mark_rts.c (GC_is_static_root): Define only if not THREADS. + * os_dep.c (GC_get_stack_base): Make public (for OpenBSD). + * os_dep.c (GC_page_was_ever_dirty): Comment out the function + except for PROC_VDB. + * tests/test.c (main): Don't reference GC_print_obj, + GC_make_closure, GC_debug_invoke_finalizer, + GC_page_was_ever_dirty, GC_is_fresh (in GC_noop). + * thread_local_alloc.c: Don't include "gc_inline.h". + * win32_threads.c (GC_write_fault_handler): Declare only if + MPROTECT_VDB. + +2009-10-21 Ivan Maidanski + + * allchblk.c (DEBUG): Remove macro (since unused). + * allchblk.c: Include private/gc_priv.h before other includes and + definitions. + * alloc.c: Ditto. + * gc_dlopen.c: Ditto. + * headers.c: Ditto. + * mallocx.c: Ditto. + * mark_rts.c: Ditto. + * new_hblk.c: Ditto. + * reclaim.c: Ditto. + * mark.c: Include private/gc_pmark.h before other includes. + * misc.c: Ditto. + * dyn_load.c (_GNU_SOURCE): Move the definition to gc_priv.h. + * pthread_support.c (_USING_POSIX4A_DRAFT10): Ditto. + * pthread_support.c (_POSIX4A_DRAFT10_SOURCE): Remove (since + already defined in gc_config_macros.h). + * dyn_load.c (GC_init_dyld): Remove parameter cast for + _dyld_register_func_for_add_image() and + _dyld_register_func_for_remove_image(); add the comment about + possible warnings; add FIXME for the deprecated + _dyld_bind_fully_image_containing_address(). + * include/private/gc_priv.h: Include gc.h before the standard + headers inclusion. + * tests/test.c: Ditto. + * include/private/gcconfig.h (DebugBreak): Update the comment. + * typd_mlc.c (ED_INITIAL_SIZE): Remove ';'. + * alloc.c: Reformat the code (partly adjust indentation). + * backgraph.c: Ditto. + * blacklst.c: Ditto. + * checksums.c: Ditto. + * finalize.c: Ditto. + * gcj_mlc.c: Ditto. + * mach_dep.c: Ditto. + * mark_rts.c: Ditto. + * obj_map.c: Ditto. + * os_dep.c: Ditto. + * ptr_chck.c: Ditto. + * stubborn.c: Ditto. + * thread_local_alloc.c: Ditto. + * typd_mlc.c: Ditto. + +2009-10-20 Ivan Maidanski (really mostly OpenBSD contributors) + + * configure.ac (openbsd): Define GC_OPENBSD_THREADS. + * configure.ac: Add AM_CONDITIONAL(OPENBSD_THREADS). + * configure.ac: Add sparc-openbsd case. + * doc/README.macros (GC_NETBSD_THREADS, GC_OPENBSD_THREADS): + Document. + * tests/test.c (main): Handle OpenBSD case. + * extra/threadlibs.c: Add the copyright header; expand all tabs to + spaces; remove trailing spaces at EOLn. + * include/private/pthread_stop_world.h: Ditto. + * extra/threadlibs.c (main): Replace K&R-style function definition + with the ANSI C one. + * extra/threadlibs.c (main): Handle GC_OPENBSD_THREADS case. + * dyn_load.c (OPENBSD): Recognize (similar to NETBSD). + * include/gc_config_macros.h (GC_SOLARIS_THREADS): Recognize; + define it for OpenBSD. + * include/gc_pthread_redirects.h (GC_pthread_sigmask, + pthread_sigmask): Don't declare and redefine for OpenBSD. + * include/private/gcconfig.h: Handle OpenBSD (on arm, sh, i386, + amd64, powerpc). + * mach_dep.c (NO_GETCONTEXT): Ditto. + * include/private/pthread_stop_world.h (thread_stop_info): Don't + define last_stop_count field if OpenBSD. + * misc.c (GC_init_dyld): Add declaration (if NetBSD). + * misc.c (GC_init): Don't call GC_init_netbsd_elf() for OpenBSD. + * os_dep.c (GC_init_netbsd_elf): Don't define for OpenBSD. + * os_dep.c (old_segv_act, GC_jmp_buf_openbsd): New static variable + (only if OpenBSD). + * os_dep.c (GC_fault_handler_openbsd, GC_find_limit_openbsd, + GC_skip_hole_openbsd): New static function (only if OpenBSD). + * os_dep.c (GC_get_stack_base, GC_get_main_stack_base, + GC_register_data_segments): Define specially for OpenBSD case. + * os_dep.c (GC_fault_handler_lock): Initialize to + AO_TS_INITIALIZER (instead of 0). + * pthread_support.c (GC_allocate_lock): Ditto. + * pthread_stop_world.c (NSIG, GC_print_sig_mask, + GC_remove_allowed_signals, suspend_handler_mask, GC_stop_count, + GC_world_is_stopped, GC_retry_signals, SIG_THR_RESTART, + GC_suspend_ack_sem, GC_suspend_handler_inner, GC_suspend_handler, + GC_restart_handler): Don't define and use if OpenBSD. + * pthread_stop_world.c (GC_suspend_all, GC_stop_world, + GC_start_world): Handle OpenBSD case. + * pthread_stop_world.c (GC_stop_init): Define as empty if OpenBSD. + * pthread_support.c (pthread_sigmask): Don't undefine the macro and + don't define the wrapper function if OpenBSD. + * pthread_support.c (GC_thr_init): Handle OpenBSD case. + * configure: Regenerate. + * include/private/config.h.in: Ditto. + +2009-10-20 Ivan Maidanski (really Petter Urkedal) + + * dyn_load.c: Move the inclusion of private/gc_priv.h below + definition of a feature macro (_GNU_SOURCE). + +2009-10-20 Ivan Maidanski + + * include/gc.h (REVEAL_POINTER): Remove redundant parentheses. + * include/gc.h (GC_HIDE_POINTER, GC_REVEAL_POINTER): New macros + (only if GC_I_HIDE_POINTERS). + * backgraph.c (GET_OH_BG_PTR): Prefix REVEAL_POINTER() with "GC_". + * dbg_mlc.c (GC_get_back_ptr_info): Ditto. + * finalize.c (GC_grow_table, GC_dump_finalization, GC_finalize, + GC_enqueue_all_finalizers): Ditto. + * backgraph.c (SET_OH_BG_PTR): Prefix HIDE_POINTER() with "GC_". + * finalize.c (GC_general_register_disappearing_link, + GC_unregister_disappearing_link, GC_register_finalizer_inner, + GC_finalize): Ditto. + * include/private/dbg_mlc.h (HIDE_BACK_PTR): Ditto. + * include/private/dbg_mlc.h (GC_I_HIDE_POINTERS): Define instead + of I_HIDE_POINTERS. + * include/private/gc_priv.h (GC_I_HIDE_POINTERS): Ditto. + * include/gc.h (_GC_H): Strip leading underscore. + * include/gc_backptr.h (_GC_H): Ditto. + * include/gc_gcj.h (_GC_H): Ditto. + * include/gc_mark.h (_GC_H): Ditto. + * include/gc_typed.h (_GC_TYPED_H, _GC_H): Ditto. + * include/javaxfc.h (_GC_H): Ditto. + * include/new_gc_alloc.h (__GC_SPECIALIZE): Ditto. + * include/private/dbg_mlc.h (_GC_H): Ditto. + * include/private/gc_priv.h (_GC_H): Ditto. + * include/gc_backptr.h: Reformat the code (adjust indentation, + comment out function parameter names). + * include/gc_gcj.h: Ditto. + * include/gc_mark.h: Ditto. + * include/gc_typed.h: Ditto. + * include/javaxfc.h: Ditto. + * include/private/dbg_mlc.h: Ditto. + * include/private/gc_priv.h: Ditto. + +2009-10-19 Ivan Maidanski + + * gc_cpp.cc: Include "gc_cpp.h" instead of . + +2009-10-19 Ivan Maidanski + + * include/private/gc_priv.h (GC_INNER): New macro (for GC-scope + variable definitions). + * include/private/gc_priv.h (GC_EXTERN): Update the comment. + * allchblk.c (GC_unmap_threshold): Define as GC_INNER. + * alloc.c (GC_incremental, GC_world_stopped, GC_n_heap_sects, + GC_n_memory, GC_fail_count): Ditto. + * blacklst.c (GC_black_list_spacing, GC_print_heap_obj): Ditto. + * gcj_mlc.c (GC_gcj_malloc_initialized, GC_gcjobjfreelist): Ditto. + * mach_dep.c (GC_save_regs_ret_val): Ditto. + * mark.c (GC_n_mark_procs, GC_obj_kinds, GC_n_kinds, + GC_mark_stack, GC_mark_stack_limit, GC_mark_stack_size, + GC_mark_stack_top, GC_mark_state, GC_mark_stack_too_small, + GC_mark_no, GC_markers): Ditto. + * mark_rts.c (GC_root_size, GC_push_typed_structures): Ditto. + * misc.c (GC_allocate_ml, GC_debugging_started, GC_check_heap, + GC_print_all_smashed, GC_print_back_height, GC_dump_regularly, + GC_backtraces, GC_force_unmap_on_gcollect, + GC_large_alloc_warn_interval, GC_is_initialized, GC_write_cs, + GC_current_warn_proc, GC_blocked_sp, GC_activation_frame): Ditto. + * os_dep.c (GC_page_size, GC_dont_query_stack_min, + GC_no_win32_dlls, GC_wnt, GC_sysinfo, GC_push_other_roots, + GC_dirty_maintained, GC_fault_handler_lock): Ditto. + * pthread_support.c (GC_allocate_ml, GC_lock_holder, + GC_need_to_lock, GC_thr_initialized, GC_threads, + GC_in_thread_creation, GC_collecting, GC_allocate_lock, + GC_mark_lock_holder): Ditto. + * reclaim.c (GC_bytes_found, GC_fl_builder_count, GC_have_errors): + Ditto. + * win32_threads.c (GC_allocate_ml, GC_lock_holder, + GC_need_to_lock, GC_mark_lock_holder, GC_collecting): Ditto. + * extra/gc.c (GC_INNER, GC_EXTERN): Define as STATIC. + * mach_dep.c (GC_with_callee_saves_pushed): Remove redundant {}. + * os_dep.c (GC_init_win32): Reformat the comment. + +2009-10-19 Ivan Maidanski + + * include/private/gc_priv.h (GC_bytes_allocd, GC_objfreelist, + GC_aobjfreelist): Replace GC_EXTERN to extern for SEPARATE_GLOBALS + case (since they are not defined inside GC at present). + * include/private/gc_priv.h (GC_objects_are_marked): Remove the + declaration (since made static). + * mark.c (GC_objects_are_marked): Define as STATIC. + * win32_threads.c (GC_thr_initialized, GC_in_thread_creation): + Ditto. + * mark.c (GC_N_KINDS_INITIAL_VALUE): New macro (defined and used + to initialize GC_n_kinds). + * win32_threads.c (start_mark_threads): Adjust the comment. + +2009-10-19 Ivan Maidanski + + * alloc.c (GC_notify_full_gc): Use GC_INLINE for a tiny static + function. + * backgraph.c (pop_in_progress, GC_apply_to_each_object): Ditto. + * mark_rts.c (add_roots_to_index): Ditto. + +2009-10-19 Ivan Maidanski + + * extra/gc.c: New file. + * Makefile.am (EXTRA_DIST): Add "extra/gc.c". + * configure: Regenerate. + * Makefile.in: Ditto. + +2009-10-19 Ivan Maidanski + + * misc.c (GC_log): Remove the declaration; move the definition (to + the place where it is used); make STATIC. + * misc.c (GC_init): Use GC_err_printf() instead of GC_log_printf() + to print open log failure. + * misc.c (GC_write): Don't abort on open log failure if the GC is + compiled with GC_PRINT_VERBOSE_STATS (useful for WinCE). + +2009-10-19 Ivan Maidanski (really Andreas Tobler) + + * include/private/gcconfig.h (USE_MMAP): Guard with ifndef. + +2009-10-18 Ivan Maidanski + + * allchblk.c (GC_fail_count, GC_large_alloc_warn_interval): Move + the variable declaration to gc_priv.h. + * alloc.c (GC_bytes_found, GC_unmap_threshold, + GC_force_unmap_on_gcollect): Ditto. + * dyn_load.c (GC_no_win32_dlls, GC_wnt): Ditto. + * finalize.c (GC_fail_count): Ditto. + * include/private/gc_locks.h (GC_allocate_ml, GC_lock_holder, + GC_collecting, GC_mark_lock_holder, GC_need_to_lock): Ditto. + * include/private/gc_pmark.h (GC_n_mark_procs, GC_mark_stack_size, + GC_mark_stack_limit, GC_mark_stack_top, GC_mark_stack, + GC_mark_stack_too_small, GC_mark_state): Ditto. + * include/private/pthread_support.h (GC_threads, + GC_thr_initialized, GC_in_thread_creation): Ditto. + * mallocx.c (GC_bytes_found): Ditto. + * mark_rts.c (GC_save_regs_ret_val, GC_world_stopped): Ditto. + * misc.c (GC_unmap_threshold): Ditto. + * os_dep.c (GC_unmap_threshold): Ditto. + * pthread_support.c (GC_markers): Ditto. + * thread_local_alloc.c (GC_gcjobjfreelist, + GC_gcj_malloc_initialized, GC_gcj_kind): Ditto. + * win32_threads.c (GC_fault_handler_lock, GC_write_cs, + GC_dont_query_stack_min, GC_markers, GC_wnt): Ditto. + * include/private/gc_priv.h (GC_EXTERN): New macro (used mostly as + a tag for now); defined after "gcconfig.h" inclusion. + * include/private/gc_priv.h: Use GC_EXTERN instead of "extern" + keyword for most global variables. + * alloc.c (GC_copyright): Add the comment about the symbol + visibility. + * finalize.c (GC_fo_entries): Ditto. + * include/private/gc_priv.h (GC_print_stats): Ditto. + * misc.c (GC_quiet): Ditto. + * mallocx.c (GC_bytes_allocd_tmp): Make the volatile variable + STATIC. + * pthread_support.c (GC_threads): Add explicit zero initializer + (to make the variable definition differ from the declaration). + +2009-10-18 Ivan Maidanski + + * backgraph.c (GC_quiet): Remove the declaration (not needed + anymore since gc_priv.h is always included). + * checksums.c (GC_quiet): Ditto. + * gcj_mlc.c (GC_quiet): Ditto. + * headers.c (GC_hdr_cache_hits, GC_hdr_cache_misses): Add the + comment. + * include/private/gc_hdrs.h (GC_hdr_cache_hits, + GC_hdr_cache_misses): Ditto. + * mark.c (GC_first_nonempty): Make the volatile variable STATIC. + * pthread_stop_world.c (GC_stop_count, GC_world_is_stopped): + Ditto. + * win32_threads.c (GC_please_stop, GC_max_thread_index, + GC_mark_mutex_waitcnt): Ditto. + +2009-10-18 Ivan Maidanski + + * pthread_support.c (GC_USE_LD_WRAP): Fix a typo (swapped 'L' and + 'D') in the name. + +2009-10-17 Ivan Maidanski + + * gc_dlopen.c (GC_MUST_RESTORE_REDEFINED_DLOPEN): Define if dlopen + redirection is turned off; turn it on later when dlopen real + symbol is no longer needed (according to the comment and the same + as in dyn_load.c). + * gc_dlopen.c (WRAP_FUNC, REAL_FUNC): Rename to WRAP_DLFUNC and + REAL_DLFUNC, respectively (to have unique names since the + definitions may differ from that of the similar ones in + pthread_support.c). + * mark.c (source): Undefine the macro when no longer needed. + * os_dep.c (handler): Rename the type to GC_fault_handler_t (to + have the unique name across the project). + * os_dep.c (STAT_BUF_SIZE, STAT_READ); Guard with ifndef; add the + comment. + * pthread_support.c (STAT_BUF_SIZE, STAT_READ): Ditto. + * os_dep.c (sbrk): Undo sbrk() redirection (for ECOS) when no + longer needed. + +2009-10-17 Ivan Maidanski + + * pthread_stop_world.c (pthread_sigmask): Undefine before using + in GC_print_sig_mask() (only if DEBUG_THREADS); add the comment. + * win32_threads.c (dlopen, _beginthread): Don't undefine (since + neither redirected nor used here). + * win32_threads.c (GC_Thread_Rep): Rename "table_management" to + "tm" for short; remove "tm_" prefix. + * win32_threads.c (in_use, next): Don't define the macros; use + tm.in_use and tm.next fields, respectively (to ease debugging). + * win32_threads.c (HASH): Rename to PTHREAD_MAP_HASH (to have + unique name across the project). + +2009-10-17 Ivan Maidanski + + * include/private/gc_priv.h (I_HIDE_POINTERS): Define before gc.h + inclusion. + * include/private/gc_pmark.h (I_HIDE_POINTERS): Define if gc.h is + not included yet. + * finalize.c (I_HIDE_POINTERS): Don't define. + * include/private/dbg_mlc.h (I_HIDE_POINTERS): Ditto. + * misc.c (I_HIDE_POINTERS): Ditto. + * include/private/dbg_mlc.h (HIDE_POINTER, REVEAL_POINTER, + GC_hidden_pointer): Don't define if HIDE_POINTER is undefined. + * include/private/gc_pmark.h: Remove the comment about gc_priv.h + inclusion order. + +2009-10-17 Ivan Maidanski + + * dyn_load.c: Include gc_priv.h before using configuration + information (MACOS). + * dyn_load.c (GC_must_restore_redefined_dlopen): Rename to + GC_MUST_RESTORE_REDEFINED_DLOPEN. + +2009-10-17 Ivan Maidanski + + * backgraph.c (SET_OH_BG_PTR): Place outermost parenthesis + properly. + * darwin_stop_world.c: Replace "if DEBUG_THREADS" with + "ifdef DEBUG_THREADS". + * pthread_stop_world.c: Ditto. + * pthread_support.c: Ditto. + * include/gc_inline.h: Guard with GC_INLINE_H. + +2009-10-17 Ivan Maidanski + + * alloc.c (GC_copyright): Define as const. + * alloc.c (GC_collect_at_heapsize): Replace "static" with "STATIC" + (since the name starts with "GC_" prefix). + * dbg_mlc.c (GC_describe_type_fns): Ditto. + * dyn_load.c (GC_FirstDLOpenedLinkMap, + GC_register_dynlib_callback, GC_dyld_sections, + GC_dyld_name_for_hdr, GC_dyld_image_add, GC_dyld_image_remove): + Ditto. + * malloc.c (GC_libpthread_start, GC_libpthread_end, + GC_libld_start, GC_libld_end): Ditto. + * mark_rts.c (GC_remove_root_at_pos, GC_rebuild_root_index): + Ditto. + * os_dep.c (GC_gww_read_dirty, GC_gww_page_was_dirty, + GC_gww_page_was_ever_dirty, GC_mprotect_thread_notify, + GC_mprotect_thread_reply, GC_mprotect_thread, GC_darwin_sigbus, + GC_forward_exception): Ditto. + * pthread_support.c (GC_syms_initialized): Ditto. + * typd_mlc.c (GC_push_typed_structures_proc): Ditto. + * win32_threads.c (GC_win32_dll_threads, + GC_register_my_thread_inner, GC_lookup_pthread, GC_get_stack_min, + GC_waitForSingleObjectInfinite): Ditto. + * darwin_stop_world.c (GC_use_mach_handler_thread, + GC_use_mach_handler_thread, GC_mach_threads_count): Replace + "static" with "STATIC" and add zero initializer. + * os_dep.c (GC_task_self, GC_ports, GC_mprotect_state, + GC_sigbus_count): Ditto. + * headers.c (free_hdr): Replace "static" with GC_INLINE. + * misc.c (GC_tmp): Rename static variable to fwrite_gc_res. + * os_dep.c (memory): Rename static variable to ecos_gc_memory. + * os_dep.c (async_set_pht_entry_from_index): Make static (for + MPROTECT_VDB case). + * pthread_support.c (GC_real_pthread_create, + GC_real_pthread_sigmask, GC_real_pthread_join, + GC_real_pthread_detach, GC_init_real_syms): Use REAL_FUNC() macro + for static GC_real_XXX symbols. + * win32_threads.c (GC_may_be_in_stack): Remove "GC_" prefix. + +2009-10-17 Ivan Maidanski + + * alloc.c (GC_never_stop_func, GC_check_fl_marks, + GC_finish_collection): Reformat the code (make opening bracket + style uniform across the file). + * allchblk.c (GC_allochblk): Ditto. + * backgraph.c (add_edge): Ditto. + * dbg_mlc.c (GC_marked_for_finalization): Ditto. + * dyn_load.c (GC_register_dynamic_libraries, GC_init_dyld): Ditto. + * finalize.c (GC_null_finalize_mark_proc): Ditto. + * gc_dlopen.c (GC_dlopen): Ditto. + * mark.c (GC_push_marked1, GC_push_marked2, GC_push_marked4): + Ditto. + * misc.c (looping_handler, GC_call_with_gc_active, + GC_do_blocking_inner, GC_do_blocking): Ditto. + * os_dep.c (GC_get_main_stack_base, GC_read_dirty): Ditto. + * pthread_support.c (GC_pthread_create, GC_pthread_sigmask, + GC_pthread_join, GC_pthread_detach, GC_check_tls, + GC_do_blocking_inner, GC_call_with_gc_active): Ditto. + * reclaim.c (GC_reclaim_clear, GC_reclaim_block, + GC_print_free_list): Ditto. + * os_dep.c (GC_page_was_dirty, GC_page_was_ever_dirty, + GC_remove_protection): Reformat the code (wrap long lines). + +2009-10-16 Ivan Maidanski + + * alloc.c (GC_finish_collection): Replace getenv() with GETENV(). + * dyn_load.c (GC_init_dyld): Ditto. + * os_dep.c (GC_print_callers): Ditto. + * dyn_load.c (GC_dyld_name_for_hdr): Cast _dyld_get_image_name() + result (since it's always of "struct mach_header" type). + * dyn_load.c (GC_init_dyld): Cast GC_dyld_image_add and + GC_dyld_image_remove (to always have the first argument of + "struct mach_header" pointer type). + +2009-10-16 Ivan Maidanski (really Petter Urkedal) + + * configure.ac: Add threads support for OpenBSD case (threads may + not work correctly for it). + * configure: Regenerate. + +2009-10-15 Ivan Maidanski (really Petter Urkedal) + + * acinclude.m4: Rename to m4/gc_set_version.m4. + * aclocal.m4: Regenerate. + * configure: Ditto. + * Makefile.in: Ditto. + * m4/libtool.m4: Delete the file. + * m4/lt~obsolete.m4: Ditto. + * m4/ltoptions.m4: Ditto. + * m4/ltsugar.m4: Ditto. + * m4/ltversion.m4: Ditto. + +2009-10-15 Ivan Maidanski + + * include/private/gcconfig.h: Define DebugBreak() as _exit(-1) for + x86mingw32ce toolchain to workaround the incorrect DebugBreak() + declaration in winbase.h (the workaround would turn into a no-op + when DebugBreak() will be defined as a macro in the toolchain). + +2009-10-15 Ivan Maidanski + + * include/private/gcconfig.h: Recognize __i386__ if WinCE (for + x86mingw32ce toolchain). + * include/private/gcconfig.h (NO_GETENV): Don't define for CeGCC + toolchain (or if already defined). + * include/private/gcconfig.h (NO_GETENV_WIN32): New macro (always + defined for WinCE or if NO_GETENV is defined). + * misc.c (GC_CreateLogFile): Use NO_GETENV_WIN32 macro instead of + NO_GETENV one. + +2009-10-15 Ivan Maidanski (really Petter Urkedal) + + * configure.ac: Add AC_CONFIG_MACRO_DIR([m4]). + * Makefile.am: Add "ACLOCAL_AMFLAGS = -I m4". + * libtool.m4: Remove. + * aclocal.m4: Regenerate. + * configure: Ditto. + * Makefile.in: Ditto. + * m4/libtool.m4: New file (generated). + * m4/lt~obsolete.m4: Ditto. + * m4/ltoptions.m4: Ditto. + * m4/ltsugar.m4: Ditto. + * m4/ltversion.m4: Ditto. + +2009-10-10 Ivan Maidanski + + * include/gc.h (GC_UNDERSCORE_STDCALL): Recognize new macro; + prefix GC_CreateThread and GC_ExitThread with '_' if defined. + * doc/README.macros (GC_UNDERSCORE_STDCALL): Document. + +2009-10-09 Ivan Maidanski + + * alloc.c (GC_collect_or_expand): Add "retry" argument; add the + comments; don't use "default" stop_func on a retry if + GC_dont_expand. + * alloc.c (GC_collect_or_expand): Reformat the code (make the + indentation style uniform across the function). + * alloc.c (GC_allocobj): Pass "retry" argument to + GC_collect_or_expand(). + * malloc.c (GC_alloc_large): Ditto. + * include/private/gc_priv.h (GC_collect_or_expand): Move the + declaration to malloc.c; add "retry" argument. + +2009-10-09 Ivan Maidanski + + * alloc.c (GC_start_call_back): Move the variable definition from + misc.c. + * include/private/gc_priv.h (GC_start_call_back): Remove the + declaration. + * alloc.c (GC_notify_full_gc): Remove unnecessary cast of 0. + * alloc.c (GC_try_to_collect_inner): Also call stop_func at the + beginning of the function. + * include/gc.h (GC_try_to_collect): Refine the comment about + stop_func. + +2009-10-08 Ivan Maidanski + + * alloc.c (GC_default_stop_func, GC_try_to_collect_general, + GC_gcollect): Add the comment. + * alloc.c (GC_try_to_collect_general): Move the assertion on + stop_func != 0 to GC_try_to_collect(). + * alloc.c (GC_try_to_collect_general): If stop_func == 0 then use + GC_default_stop_func instead (holding the lock). + * alloc.c (GC_gcollect): Pass 0 as stop_func instead of + GC_default_stop_func (to prevent data races). + +2009-10-08 Ivan Maidanski + + * Makefile.direct: Move "define arguments" documentation to + doc/README.macros; add reference to doc/README.macros. + * Makefile.dj: Change the documentation reference to + doc/README.macros. + * README.QUICK: Ditto. + * configure.ac: Ditto. + * allchblk.c: Remove unnecessary "-D" from the comment. + * doc/README.macros: Ditto. + * README.environment: Ditto. + * include/gc.h: Ditto. + * include/gc_inline.h: Ditto. + * include/private/gcconfig.h: Ditto. + * README.QUICK: Fix a typo. + * README.QUICK: Expand all tabs to spaces. + * configure: Regenerate. + * include/private/config.h.in: Ditto. + +2009-10-07 Ivan Maidanski + + * misc.c (GC_CreateLogFile): Use FILE_ATTRIBUTE_NORMAL for + CreateFile(); don't immediately flush every write if very verbose. + +2009-10-07 Ivan Maidanski + + * doc/README.win32: Replace ".exe.log" to ".gc.log". + * doc/README.win64: Ditto. + * doc/README.win64: Fix a typo. + * misc.c (GC_CreateLogFile): Strip executable file extension for + the log file; use ".gc.log" extension (instead of ".log"). + +2009-10-07 Ivan Maidanski + + * include/gc_config_macros.h: Avoid the redefinition of + GC_xxx_THREADS macros. + +2009-10-06 Ivan Maidanski + + * alloc.c (GC_try_to_collect_general): Change the type of "result" + local variable to GC_bool. + +2009-10-06 Ivan Maidanski + + * include/gc_config_macros.h: Use old behavior for FreeBSD and + NetBSD platform detection code (check that other GC_xxx_THREADS + are undefined); add FIXME. + +2009-10-06 Ivan Maidanski + + * include/gc_config_macros.h: Rearrange the platform detection + code (GC_WIN32_PTHREADS implies GC_WIN32_THREADS; define + GC_THREADS first if GC_XXX_THREADS already set; define proper + GC_XXX_THREADS if GC_THREADS; define GC_PTHREADS in a single + place; define _REENTRANT if posix threads except for Win32). + * include/gc_config_macros.h: Reformat the code (make the + indentation style uniform across the file). + +2009-10-06 Ivan Maidanski + + * alloc.c (GC_try_to_collect_general): New function (move the code + from GC_try_to_collect, pass force_unmap argument). + * alloc.c (GC_try_to_collect, GC_gcollect): Call + GC_try_to_collect_general(). + * alloc.c (GC_gcollect_and_unmap): New public function. + * include/gc.h (GC_gcollect_and_unmap): New function declaration. + * tests/test.c (window_proc): Call GC_gcollect_and_unmap() on + WM_HIBERNATE event (instead of GC_set_force_unmap_on_gcollect() + and GC_gcollect()). + +2009-10-06 Ivan Maidanski + + * include/gc.h (GC_allow_register_threads, GC_register_my_thread, + GC_unregister_my_thread, GC_malloc_many): Refine the comment. + * include/gc.h (GC_malloc_many, GC_NEXT): Declare unconditionally + (that is, don't depend on GC_THREADS macro). + * include/gc.h: Don't check for __CYGWIN32__ and __CYGWIN__ along + with a check for GC_PTHREADS (since the former implies the + latter). + +2009-10-06 Ivan Maidanski + + * include/gc.h: Reformat the code (make the indentation style + uniform across the file). + * include/gc.h (GC_SOLARIS_THREADS): Don't check for. + * include/gc.h (GC_MIN, GC_MAX): Don't define. + * mallocx.c (GC_malloc_many): Add comment to #endif. + +2009-10-02 Ivan Maidanski (really Petter Urkedal) + + * configure.ac: Drop the subdir-objects Automake option, since + it's incompatible with picking source files from libatomic_ops. + * Makefile.in: Regenerate. + +2009-10-01 Ivan Maidanski (really mostly Andreas Tobler) + + * allchblk.c (GC_fail_count, GC_large_alloc_warn_interval): Add + "extern" keyword to a global variable declaration (some compilers + require it). + * alloc.c (GC_bytes_found, GC_unmap_threshold, + GC_force_unmap_on_gcollect): Ditto. + * dyn_load.c (GC_no_win32_dlls, GC_wnt): Ditto. + * finalize.c (GC_fail_count): Ditto. + * include/private/gc_hdrs.h (GC_hdr_cache_hits, + GC_hdr_cache_misses): Ditto. + * mallocx.c (GC_bytes_found): Ditto. + * mark_rts.c (GC_save_regs_ret_val, GC_world_stopped): Ditto. + * misc.c (GC_unmap_threshold): Ditto. + * os_dep.c (GC_unmap_threshold, GC_old_allocator): Ditto. + * pthread_support.c (GC_markers): Ditto. + * thread_local_alloc.c (GC_gcjobjfreelist, + GC_gcj_malloc_initialized, GC_gcj_kind): Ditto. + * win32_threads.c (GC_fault_handler_lock, GC_write_cs, + GC_dont_query_stack_min, GC_markers, GC_wnt): Ditto. + +2009-10-01 Ivan Maidanski + + * Makefile.in: Regenerate (by autoreconf -vif, deleting libtool.m4 + first and using libtool-2.2, automake-1.10.2, autoconf-2.64). + * aclocal.m4: Ditto. + * config.guess: Ditto. + * config.sub: Ditto. + * configure: Ditto. + * depcomp: Ditto. + * install-sh: Ditto. + * ltmain.sh: Ditto. + * missing: Ditto. + * mkinstalldirs: Ditto. + * include/private/config.h.in: Ditto. + +2009-10-01 Ivan Maidanski + + * tests/huge_test.c: Define GC_IGNORE_WARN (if not defined) to + suppress misleading GC "Out of Memory!" warning printed on every + GC_MALLOC(LONG_MAX) call. + * tests/huge_test.c: Include "gc.h" instead of . + * tests/huge_test.c (main): Replace K&R-style function definition + with the ANSI C one. + * tests/huge_test.c: Expand all tabs to spaces. + +2009-10-01 Ivan Maidanski + + * dyn_load.c (GC_register_dynamic_libraries): Always use + lpMaximumApplicationAddress value for WinCE (even for old + versions). + * os_dep.c (VER_PLATFORM_WIN32_CE): Define if not in winbase.h. + * os_dep.c (GC_dont_query_stack_min): New global variable (only if + WinCE and THREADS). + * os_dep.c (GC_setpagesize): Adjust lpMaximumApplicationAddress + for WinCE (prior to version 6) if not _WIN32_WCE_EMULATION; set + GC_dont_query_stack_min for older WinCE (prior to version 5). + * win32_threads.c (GC_dont_query_stack_min): Declare. + * win32_threads.c (GC_get_stack_min): Rename the macro to + GC_wince_evaluate_stack_min for WinCE; update the comment. + * win32_threads.c (GC_push_stack_for, GC_get_next_stack): Use + GC_wince_evaluate_stack_min() instead of GC_get_stack_min() for + WinCE and don't update thread's last_stack_min value (only if + GC_dont_query_stack_min). + * win32_threads.c (GC_push_stack_for): Skip assertion for WinCE if + GC_dont_query_stack_min (since the evaluated stack_min value may + be incorrect if the stack is bigger than 64 KiB). + +2009-10-01 Ivan Maidanski + + * gc_dlopen.c (GC_dlopen): Add function redirector (only if + GC_USE_LD_WRAP). + * include/gc.h: Include "gc_pthread_redirects.h" even if + GC_USE_LD_WRAP or GC_NO_THREAD_REDIRECTS. + * include/gc_pthread_redirects.h (GC_PTHREAD_REDIRECTS_H): Don't + define and check for (since included only from gc.h). + * include/gc_pthread_redirects.h: Declare "GC_" symbols even if + GC_USE_LD_WRAP or GC_NO_THREAD_REDIRECTS. + * include/gc_pthread_redirects.h: Include signal.h only to get + sigset_t definition. + +2009-09-30 Ivan Maidanski + + * configure: Regenerate (by autoreconf -vif, deleting libtool.m4 + first). + * Makefile.in: Ditto. + * aclocal.m4: Ditto. + * include/private/config.h.in: Ditto. + +2009-09-30 Ivan Maidanski + + * Makefile.direct: Remove trailing spaces at EOLn. + * Makefile.direct: Document GC_REGISTER_MEM_PRIVATE. + * mark_rts.c (GC_is_tmp_root): Define also for WinCE unless + NO_DEBUGGING (that is, replace _WIN32_WCE_EMULATION with MSWINCE). + * os_dep.c (GC_sysinfo): Remove explicit global variable + initialization to "{0}" (revert back the previous change) since it + might produce a warning. + +2009-09-30 Ivan Maidanski + + * allchblk.c (GC_large_alloc_warn_interval): Move declaration from + gc_priv.h. + * allchblk.c (GC_large_alloc_warn_suppressed): Move definition + from misc.c; define as STATIC. + * include/private/gc_priv.h (GC_large_alloc_warn_interval, + GC_large_alloc_warn_suppressed): Remove declaration. + * alloc.c (GC_bytes_found): Add "defined in" comment. + * mallocx.c (GC_bytes_found): Ditto. + * misc.c (GC_unmap_threshold): Ditto. + * os_dep.c (GC_old_allocator): Ditto. + * pthread_support.c (GC_markers): Ditto. + * thread_local_alloc.c (GC_gcjobjfreelist, + GC_gcj_malloc_initialized, GC_gcj_kind): Ditto. + * win32_threads.c (GC_markers): Ditto. + * alloc.c (GC_start_time): Explicitly initialize to 0 or NULL (to + be distinctive from a variable declaration). + * backgraph.c (GC_max_height, GC_deepest_obj): Ditto. + * blacklst.c (GC_old_normal_bl, GC_incomplete_normal_bl, + GC_old_stack_bl, GC_incomplete_stack_bl): Ditto. + * checksums.c (GC_faulted, GC_n_dirty_errors, + GC_n_faulted_dirty_errors, GC_n_changed_errors, GC_n_clean, + GC_n_dirty, GC_bytes_in_used_blocks): Ditto. + * dbg_mlc.c (GC_smashed): Ditto. + * finalize.c (GC_old_dl_entries): Ditto. + * gcj_mlc.c (GC_gcj_kind, GC_gcj_debug_kind, GC_gcjobjfreelist, + GC_gcjdebugobjfreelist): Ditto. + * mach_dep.c (GC_save_regs_ret_val): Ditto. + * mark.c (GC_n_rescuing_pages, GC_mark_stack, GC_mark_stack_limit, + GC_mark_stack_top): Ditto. + * misc.c (GC_min_sp, GC_high_water, GC_bytes_allocd_at_reset): + Ditto. + * os_dep.c (GC_data_start, GC_page_size, GC_sysinfo, + GC_old_segv_handler, GC_old_bus_handler, + GC_old_bus_handler_used_si, GC_old_segv_handler_used_si, + GC_proc_buf, GC_proc_fd, GC_vd_base): Ditto. + * pthread_stop_world.c (GC_stop_count, GC_stopping_pid): Ditto. + * reclaim.c (GC_leaked): Ditto. + * typd_mlc.c (GC_explicit_kind, GC_array_kind, GC_ext_descriptors, + GC_typed_mark_proc_index, GC_array_mark_proc_index, + GC_eobjfreelist, GC_arobjfreelist): Ditto. + * win32_threads.c (GC_pthread_map_cache, GC_marker_cv, + GC_marker_Id): Ditto. + * dbg_mlc.c (GC_smashed, GC_n_smashed): Define as STATIC. + * gcj_mlc.c (GC_gcjdebugobjfreelist): Ditto. + * os_dep.c (GC_vd_base): Ditto. + * pthread_support.c (GC_mark_threads): Ditto. + * reclaim.c (GC_leaked): Ditto. + * typd_mlc.c (GC_bm_table): Ditto. + * mark_rts.c (GC_save_regs_ret_val): Change declaration type to + that of definition; add "defined in" comment. + * mark_rts.c (GC_push_current_stack): Remove unnecessary cast for + GC_save_regs_ret_val. + * misc.c (GC_check_heap, GC_print_all_smashed, + GC_start_call_back): Remove unnecessary cast (of 0). + * misc.c (GC_LARGE_ALLOC_WARN_INTERVAL): New tuning macro. + * misc.c (GC_large_alloc_warn_interval): Initialize to + GC_LARGE_ALLOC_WARN_INTERVAL value. + * misc.c (GC_tmp): Change to "static". + * os_dep.c (GC_setpagesize): Reformat the code (collapse multiple + function definitions). + * os_dep.c (GC_mprotect_state): Define as static. + * pthread_support.c (dummy_thread_local): Prefix with "GC_". + * win32_threads.c (WinMain): Remove FIXME for WinCE. + +2009-09-30 Ivan Maidanski (really Hans Boehm) + + * os_dep.c (PROTECT, UNPROTECT): Use distinct ABORT messages. + +2009-09-30 Ivan Maidanski (really Petter Urkedal) + + * configure.ac: Rewrite the tests for external or internal + libatomic_ops. + * configure.ac: In particular, drop the symbolic links. Add option + --with-libatomic-ops for forced selection. + * Makefile.am: Adjust the path of source files from libatomic_ops + to not use the links. + * Makefile.am (libgc_la_LIBADD): Add $(ATOMIC_OPS_LIBS). This will + be empty if we use the bundled AO sources. + * configure: Regenerate. + * Makefile.in: Ditto. + +2009-09-29 Ivan Maidanski + + * Makefile.am: Strip version suffix for libatomic_ops directory. + * build_atomic_ops.sh: Ditto. + * build_atomic_ops.sh.cygwin: Ditto. + * configure_atomic_ops.sh: Ditto. + * Makefile.direct: Remove AO_VERSION definition; strip version + suffix for libatomic_ops directory. + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_THREADS_MAKEFILE: Ditto. + * gc.mak: Ditto. + * Makefile.in: Regenerate. + +2009-09-29 Ivan Maidanski + + * libatomic_ops: Rename from "libatomic_ops-1.2". + +2009-09-28 Ivan Maidanski + + * alloc.c (GC_version): Add "const" keyword. + * alloc.c (GC_get_version): New public function. + * include/gc.h (GC_get_version): New function declaration; update + the comment for the GC version. + +2009-09-27 Ivan Maidanski + + * include/private/gc_locks.h (GC_allocate_ml, GC_lock_holder, + GC_collecting, GC_mark_lock_holder, GC_need_to_lock): Use "extern" + (for the global variable declaration) again. + * include/private/gc_pmark.h (GC_n_mark_procs, GC_mark_stack_size, + GC_mark_stack_limit, GC_mark_stack_top, GC_mark_stack, + GC_mark_stack_too_small, GC_mark_state): Ditto. + * include/private/gcconfig.h (GC_register_stackbottom): Ditto. + * include/private/pthread_support.h (GC_threads, + GC_thr_initialized, GC_in_thread_creation): Ditto. + * include/private/gc_priv.h: Ditto (for all global variables). + +2009-09-27 Ivan Maidanski + + * real_malloc.c: Include private/config.h if HAVE_CONFIG_H. + +2009-09-27 Ivan Maidanski + + * allchblk.c (GC_hblkfreelist): Define as STATIC. + * blacklst.c (GC_total_stack_black_listed): Ditto. + * include/private/gc_priv.h (GC_hblkfreelist, GC_stopped_mark, + GC_total_stack_black_listed, GC_push_stubborn_structures): Remove + declaration. + * mark_rts.c (GC_stopped_mark): Add declaration (only if + THREAD_LOCAL_ALLOC). + * allchblk.c (GC_fail_count): Move the declaration out of + GC_allochblk_nth(); remove "extern". + * alloc.c (IF_THREADS): Remove unused macro. + * alloc.c (GC_world_stopped): Define only if THREAD_LOCAL_ALLOC. + * alloc.c (GC_stopped_mark): Set GC_world_stopped value only if + THREAD_LOCAL_ALLOC. + * alloc.c (GC_bytes_found, GC_collection_in_progress, + GC_check_tls, GC_unmap_threshold, GC_force_unmap_on_gcollect): + Remove K&R-style "extern" for the declaration. + * dbg_mlc.c (GC_free_inner): Ditto. + * dyn_load.c (GC_repeat_read, GC_roots_present, GC_is_heap_base, + GC_get_next_stack, GC_no_win32_dlls, GC_wnt): Ditto. + * finalize.c (GC_fail_count): Ditto. + * include/private/gc_hdrs.h (GC_hdr_cache_hits, + GC_hdr_cache_misses): Ditto. + * include/private/gc_locks.h (GC_allocate_ml, GC_lock_holder, + GC_lock, GC_collecting, GC_mark_lock_holder, GC_need_to_lock): + Ditto. + * include/private/gc_pmark.h (GC_mark_procs, GC_n_mark_procs, + GC_mark_stack_size, GC_mark_stack_limit, GC_mark_stack_top, + GC_mark_stack, GC_mark_stack_too_small, GC_mark_state): Ditto. + * include/private/gc_priv.h (GC_current_warn_proc, GC_obj_kinds, + GC_n_kinds, GC_fo_entries, GC_n_heap_sects, GC_n_memory, + GC_page_size, GC_sysinfo, GC_black_list_spacing, + GC_objects_are_marked, GC_incremental, GC_dirty_maintained, + GC_root_size, GC_debugging_started, GC_large_alloc_warn_interval, + GC_large_alloc_warn_suppressed, GC_blocked_sp, + GC_activation_frame, GC_push_other_roots, + GC_push_finalizer_structures, GC_push_thread_structures, + GC_push_typed_structures, GC_start_call_back, GC_is_initialized, + GC_check_heap, GC_print_all_smashed, GC_print_all_errors, + GC_print_heap_obj, GC_have_errors, GC_print_stats, + GC_dump_regularly, GC_backtraces, GC_print_back_height, + GC_debug_generic_malloc_inner, + GC_debug_generic_malloc_inner_ignore_off_page, + GC_fl_builder_count, GC_mark_no, GC_help_marker, + GC_setup_temporary_fault_handler, GC_reset_fault_handler): Ditto. + * include/private/gcconfig.h (GC_SysVGetDataStart, + GC_FreeBSDGetDataStart, GC_register_stackbottom, + GC_MacTemporaryNewPtr, GC_amiga_get_mem): Ditto. + * include/private/pthread_support.h (GC_threads, + GC_thr_initialized, GC_in_thread_creation): Ditto. + * malloc.c (GC_text_mapping): Ditto. + * mallocx.c (GC_bytes_found): Ditto. + * mark.c (GC_check_dirty, GC_started_thread_while_stopped): Ditto. + * mark_rts.c (GC_save_regs_ret_val): Ditto. + * misc.c (GC_clear_stack_inner, GC_init_parallel, GC_init_win32, + GC_setpagesize, GC_init_linux_data_start, + GC_set_and_save_fault_handler, GC_unmap_threshold): Ditto. + * os_dep.c (GC_unmap_threshold, GC_push_all_stacks, + GC_darwin_register_mach_handler_thread): Ditto. + * pthread_support.c (GC_markers, GC_collection_in_progress): + Ditto. + * tests/test.c (GC_amiga_free_all_mem): Ditto. + * thread_local_alloc.c (GC_gcjobjfreelist, + GC_gcj_malloc_initialized, GC_gcj_kind): Ditto. + * win32_threads.c (GC_write_fault_handler, GC_gww_dirty_init, + GC_fault_handler_lock, GC_write_cs, GC_markers): Ditto. + * misc.c (GC_read, GC_register_finalizer_no_order, GC_init_dyld): + Move the declaration out of GC_init(); remove "extern". + * os_dep.c (GC_abort): Add the comment; add workaround to suppress + compiler "unreachable code" warnings for ABORT callers (where + ABORT is followed by a dummy return statement). + * os_dep.c (GC_old_allocator): Move the declaration out of + GC_default_push_other_roots(); remove "extern". + * darwin_stop_world.c (GC_mprotect_stop, GC_mprotect_resume): + Move the declaration out of GC_stop_world() and GC_start_world() + (only if MPROTECT_VDB); remove "extern". + +2009-09-27 Ivan Maidanski + + * win32_threads.c (GC_get_stack_min, GC_push_stack_for, + GC_get_next_stack): Recognize _WIN32_WCE_EMULATION macro (used for + WinCE emulation and for custom WinCE 6 devices); add the comment. + * win32_threads.c (GC_get_stack_min): Cast pointer to word instead + of DWORD. + * win32_threads.c (GC_get_next_stack): Don't use and maintain the + latest known stack_min value for WinCE (if GC_get_stack_min is + defined as a macro); update the comments. + * win32_threads.c (GC_wnt): Don't declare for WinCE. + +2009-09-26 Ivan Maidanski + + * Makefile.direct: Document EMPTY_GETENV_RESULTS. + * gcj_mlc.c (GC_clear_stack): Remove declaration. + * malloc.c (GC_clear_stack): Ditto. + * mallocx.c (GC_clear_stack): Ditto. + * typd_mlc.c (GC_clear_stack): Ditto. + * gcj_mlc.c (GENERAL_MALLOC, GENERAL_MALLOC_IOP): Rename to + GENERAL_MALLOC_INNER and GENERAL_MALLOC_INNER_IOP, respectively; + remove "lb" unnecessary cast to word. + * include/private/gc_priv.h (GC_clear_stack): Add declaration. + * include/private/gc_priv.h (GENERAL_MALLOC, GENERAL_MALLOC_IOP): + Move common declaration from typd_mlc.c and malloc.c; remove + unnecessary result and "lb" parameter casts. + * include/private/thread_local_alloc.h: Guard against duplicate + header file inclusion. + * os_dep.c (USE_MUNMAP): Replace "-->" with an error directive for + the case when USE_MMAP is not defined. + * pthread_support.c (GC_is_thread_tsd_valid): New internal + function (only if GC_ASSERTIONS and THREAD_LOCAL_ALLOC); move the + code from thread-local GC_malloc(); add FIXME for the condition. + * win32_threads.c (GC_is_thread_tsd_valid): Ditto. + * thread_local_alloc.c (GC_gcjobjfreelist): Change the type (to + match that of its definition). + * thread_local_alloc.c (GC_destroy_thread_local): Add a cast for + GC_gcjobjfreelist. + * thread_local_alloc.c (GC_lookup_thread, GC_lookup_thread_inner): + Remove unused declaration; don't include pthread.h. + * thread_local_alloc.c (GC_is_thread_tsd_valid): New declaration + (only if GC_ASSERTIONS). + * thread_local_alloc.c (GC_malloc): Use GC_is_thread_tsd_valid() + instead of GC_lookup_thread(). + * win32_threads.c (GC_lookup_thread_inner): Define as STATIC. + * win32_threads.c (UNPROTECT): Rename to UNPROTECT_THREAD (to have + id different from that in os_dep.c). + +2009-09-26 Ivan Maidanski + + * allchblk.c (GC_enough_large_bytes_left): Replace "inline static" + with GC_INLINE. + * include/private/gc_priv.h (fixed_getenv): Ditto. + * alloc.c (GC_max, GC_min): Replace "static INLINE" with + GC_INLINE. + * mark_rts.c (rt_hash): Ditto. + * win32_threads.c (GC_get_max_thread_index): Ditto. + * include/private/gc_priv.h (INLINE): Prefix with "GC_"; include + "static"; define for Sun CC; define for VC++ (and other + compilers). + * pthread_support.c: Don't define __inline__ for non-GNU compilers + (not needed anymore). + +2009-09-26 Ivan Maidanski + + * NT_THREADS_MAKEFILE: Remove file (since it duplicates gc.mak). + * Makefile.in: Remove reference to NT_THREADS_MAKEFILE. + * Makefile.am: Ditto. + * Makefile.dj: Ditto. + * Makefile.direct: Ditto. + * doc/README.win32: Add reference to gc.mak. + * NT_X64_THREADS_MAKEFILE: Ditto. + +2009-09-26 Ivan Maidanski + + * Makefile.in: Regenerate (by autoreconf -vif). + * aclocal.m4: Ditto. + * compile: Ditto. + * config.guess: Ditto. + * config.sub: Ditto. + * configure: Ditto. + * depcomp: Ditto. + * install-sh: Ditto. + * ltmain.sh: Ditto. + * missing: Ditto. + * mkinstalldirs: Ditto. + * include/private/config.h.in: New file (generated). + * Makefile.direct: Remove references to acinclude.m4, libtool.m4. + +2009-09-26 Ivan Maidanski (really Petter Urkedal) + + * autogen.sh: Update. + +2009-09-26 Ivan Maidanski (really Petter Urkedal) + + * Makefile.am: Don't add libtool.m4 to EXTRA_DIST. + * acinclude.m4: Fix underquoting of GC_SET_VERSION. + * README.QUICK: Update information for Makefile. + * Makefile.am: Do not distribute the substituted bdw-gc.pc. + * configure.ac: Add AM conditional analog to KEEP_BACK_PTRS. + * tests/tests.am: Use it here to conditionally enable tracetest + when possible. + +2009-09-26 Ivan Maidanski + + * dyn_load.c (GC_wnt): Update the comment. + * dyn_load.c (GC_register_dynamic_libraries): Add the comment for + _WIN32_WCE_EMULATION; recognize GC_REGISTER_MEM_PRIVATE (new + macro); call GC_is_heap_base() only if check for Type succeeded. + +2009-09-26 Ivan Maidanski + + * mark_rts.c (GC_is_tmp_root): Don't define unless NO_DEBUGGING; + update the comment. + * include/private/gc_priv.h (GC_is_tmp_root): Remove declaration. + +2009-09-26 Ivan Maidanski + + * alloc.c: Expand all tabs to spaces; remove trailing spaces at + EOLn; remove multiple trailing blank lines. + * misc.c: Ditto. + * os_dep.c: Ditto. + * pthread_support.c: Ditto. + * include/private/gc_priv.h: Ditto. + * include/private/gcconfig.h: Ditto. + +2009-09-25 Hans Boehm + + * include/private/gcconfig.h (CANCEL_SAFE, IF_CANCEL): new macros. + * include/private/gc_priv.h (DISABLE_CANCEL, RESTORE_CANCEL, + ASSERT_CANCEL_DISABLED): New macros. + * alloc.c (GC_maybe_gc): Assert cancellation disabled. + (GC_collect_a_little_inner,GC_try_to_collect, GC_collect_or_expand): + Disable cancellation. + (GC_add_to_our_memory): Check for overflow. + * misc.c (GC_cancel_disable_count): declare. + (GC_init, GC_write): Disable cancellation. + (GC_init): Remove redundant GC_is_initialized test. + * os_dep.c (GC_repeat_read): Assert cancellation disabled. + (GC_get_stack_base): Disable cancellation. + * pthread_stop_world.c (GC_suspend_handler_inner): Disable + cancellation. + * pthread_support.c (GC_mark_thread): Permanently disable + cancellation. + (GC_wait_for_gc_completion, GC_wait_builder, GC_wait_marker): + Assert cancellation disabled. + (fork handling): Disable cancellation, fix comment. + (GC_pthread_create): Disable cancellation. + (GC_unregister_my_thread): Disable cancellation. + * Makefile.direct: Document NO_CANCEL_SAFE. + +2009-09-25 Ivan Maidanski + + * Makefile: Remove outdated file (Makefile.direct should be used + instead). + +2009-09-25 Ivan Maidanski + + * win32_threads.c: Reformat the code (make indentation and + opening bracket style uniform across the file; wrap long code and + comment lines). + +2009-09-25 Ivan Maidanski + + * include/gc.h (GC_use_DllMain): Refine (and reformat) the + comment. + +2009-09-25 Ivan Maidanski (really mostly Petter Urkedal) + + * configure.ac: Add documentation to AC_DEFINE for GC_THREADS and + EMPTY_GETENV_RESULTS. + * configure.ac: Fix a typo. + * Makefile.am: Ditto. + +2009-09-25 Ivan Maidanski + + * checksums.c (GC_checksum, GC_update_check_page): Remove + "register" keyword in local variable declarations (for the code + used only for debugging or which is not time-critical). + * dbg_mlc.c (GC_has_other_debug_info, GC_store_debug_info, + GC_store_debug_info_inner, GC_check_annotated_obj, GC_print_obj, + GC_print_smashed_obj, GC_debug_end_stubborn_change, + GC_debug_invoke_finalizer): Ditto. + * dyn_load.c (GC_register_dynamic_libraries): Ditto. + * mallocx.c (GC_realloc): Ditto. + * mark_rts.c (GC_print_static_roots, GC_is_static_root, + GC_clear_roots): Ditto. + * misc.c (GC_write): Ditto. + * os_dep.c (GC_print_callers): Ditto. + * dyn_load.c (GC_register_dynamic_libraries): Rename "i" local + variable to "j" for the nested loop (just not to hide the similar + variable in the outer one). + * mark_rts.c (GC_print_static_roots): Output an error message + using GC_err_printf() (instead of GC_printf()). + +2009-09-25 Ivan Maidanski (really Petter Urkedal) + + * configure.ac: Move include flag from ${INCLUDE} ... + * Makefile.am: ... to AM_CPPFLAGS and also add the build directory. + * configure.ac: Call AM_CONFIG_HEADER([include/private/config.h]). + * configure.ac: Add documentation to all AC_DEFINE either directly + or using AH_TEMPLATE. + +2009-09-24 Ivan Maidanski + + * win32_threads.c (GC_waitForSingleObjectInfinite): New static + function (only if GC_WINMAIN_REDIRECT). + * win32_threads.c (WinMain): Call GC_waitForSingleObjectInfinite() + thru GC_do_blocking() instead of calling WaitForSingleObject() + directly. + +2009-09-24 Ivan Maidanski + + * pthread_support.c (start_mark_threads): Refine printed message. + * win32_threads.c (GC_thr_init): Ditto. + * win32_threads.c: Reformat some code pieces (wrap too long code + lines). + +2009-09-24 Ivan Maidanski + (ivmai145.diff) + + * Makefile.direct (GC_WINMAIN_REDIRECT): Add the comment for. + * Makefile.direct (NO_GETENV): Update the comment. + * include/gc.h (GC_WINMAIN_WINCE_LPTSTR): Remove macro. + * include/gc.h (GC_WinMain): Remove declaration. + * include/gc.h (WinMain): Define (as GC_WinMain) if and only if + GC_WINMAIN_REDIRECT. + * tests/test.c (GC_COND_INIT): Define as GC_INIT() also in case of + WinCE target unless GC_WINMAIN_REDIRECT is defined. + * tests/test.c (WINMAIN_LPTSTR): New macro. + * tests/test.c (WinMain): Use WINMAIN_LPTSTR instead of LP[W]STR + and GC_WINMAIN_WINCE_LPTSTR. + * win32_threads.c (start_mark_threads): Add the comment for + MARK_THREAD_STACK_SIZE. + * win32_threads.c: Recognize new GC_WINMAIN_REDIRECT macro. + * win32_threads.c (WINMAIN_LPTSTR, WINMAIN_THREAD_STACK_SIZE): New + macro (only if GC_WINMAIN_REDIRECT). + * win32_threads.c: Undefine WinMain macro if GC_WINMAIN_REDIRECT. + * win32_threads.c (GC_WinMain): Add prototype (only if + GC_WINMAIN_REDIRECT). + * win32_threads.c (main_thread_args, WinMain): Rename + GC_WINMAIN_WINCE_LPTSTR to WINMAIN_LPTSTR. + * win32_threads.c (WinMain): Call GC_INIT() instead of GC_init(); + use WINMAIN_THREAD_STACK_SIZE. + * win32_threads.c (WinMain): Call GC_deinit() and + DeleteCriticalSection() only if WinCE; add FIXME. + +2009-09-24 Ivan Maidanski + + * os_dep.c (GC_get_main_stack_base): add assertion for mem_base + value returned by GC_get_stack_base(). + +2009-09-23 Ivan Maidanski + (ivmai150.diff) + + * Makefile.direct (MUNMAP_THRESHOLD, GC_FORCE_UNMAP_ON_GCOLLECT): + Add the comment for. + * alloc.c (GC_unmap_threshold, GC_force_unmap_on_gcollect): + Declare external variable (only if USE_MUNMAP). + * alloc.c (GC_try_to_collect): Temporarily set GC_unmap_threshold + value to 1 if GC_force_unmap_on_gcollect and restore it before + unlocking (only if USE_MUNMAP). + * doc/README.environment (GC_FORCE_UNMAP_ON_GCOLLECT): Add + information for. + * include/gc.h (GC_set_force_unmap_on_gcollect, + GC_get_force_unmap_on_gcollect): New public function prototype. + * include/gc.h (GC_FORCE_UNMAP_ON_GCOLLECT): New macro is + recognized. + * misc.c (GC_FORCE_UNMAP_ON_GCOLLECT): Ditto. + * include/gc.h (GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT): New + internal macro (used by GC_INIT only). + * misc.c (GC_force_unmap_on_gcollect): New global variable. + * misc.c (GC_init): Recognize new "GC_FORCE_UNMAP_ON_GCOLLECT" + environment variable (and set GC_force_unmap_on_gcollect). + * misc.c (GC_set_force_unmap_on_gcollect, + GC_get_force_unmap_on_gcollect): New public function. + * tests/test.c (window_proc): Call GC_set_force_unmap_on_gcollect + to force the mode on if WM_HIBERNATE; restore the mode after + GC_gcollect(). + +2009-09-23 Ivan Maidanski + + * Makefile.direct (LARGE_CONFIG): Update information. + * include/gc.h (GC_stop_func): Refine the comment. + +2009-09-21 Ivan Maidanski + + * configure.ac: Use EMPTY_GETENV_RESULTS instead of NO_GETENV for + Win32 (workaround for Wine bug). + +2009-09-20 Ivan Maidanski + + * allchblk.c (GC_freehblk): Adjust local variables indentation. + * mallocx.c (GC_generic_malloc_many): Ditto. + * typd_mlc.c (GC_malloc_explicitly_typed_ignore_off_page, + GC_calloc_explicitly_typed): Ditto. + * typd_mlc.c (GC_make_array_descriptor): Remove unnecessary + brackets. + +2009-09-20 Ivan Maidanski + + * configure.ac: Replace GC_WIN32_THREADS with GC_THREADS. + * configure.ac: Process enable_parallel_mark option for Cygwin and + Win32; define THREAD_LOCAL_ALLOC for Win32. + +2009-09-20 Ivan Maidanski + + * include/private/gc_priv.h: Define AO_ASSUME_WINDOWS98 if + PARALLEL_MARK (required for VC++ x86). + +2009-09-19 Ivan Maidanski + (ivmai149.diff) + + * dbg_mlc.c (GC_generate_random_backtrace): Call + GC_try_to_collect(GC_never_stop_func) instead of GC_gcollect(); + if GC is disabled then print error message and return. + * include/gc.h (GC_try_to_collect): Refine the comment. + * include/private/gc_priv.h (GC_never_stop_func): Fix return type; + refine the comment. + +2009-09-19 Ivan Maidanski + (ivmai147.diff) + + * add_gc_prefix.c: Move the file to the new "extra" directory. + * AmigaOS.c: Ditto. + * gcname.c: Ditto. + * if_mach.c: Ditto. + * if_not_there.c: Ditto. + * MacOS.c: Ditto. + * msvc_dbg.c: Ditto. + * setjmp_t.c: Ditto. + * threadlibs.c: Ditto. + * EMX_MAKEFILE: Prepend setjmp_t.c with "extra" directory. + * Makefile: Prepend AmigaOS.c, MacOS.c, add_gc_prefix.c, gcname.c, + if_mach.c, if_not_there.c, msvc_dbg.c, setjmp_t.c, threadlibs.c + with "extra" directory. + * Makefile.am: Ditto. + * Makefile.direct: Ditto. + * Makefile.dj: Ditto. + * Makefile.in: Ditto. + * NT_MAKEFILE: Prepend msvc_dbg.obj with "extra" directory. + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_THREADS_MAKEFILE: Ditto. + * NT_THREADS_MAKEFILE: Prepend msvc_dbg.c with "extra" directory. + * gc.mak: Ditto. + * PCR-Makefile: Prepend if_mach.c, if_not_there.c with "extra" + directory. + * SMakefile.amiga: Prepend AmigaOS.c, setjmp_t.c with "extra" + directory. + * doc/simple_example.html: Update for threadlibs.c. + * os_dep.c: Prepend included AmigaOS.c with "extra" directory. + +2009-09-19 Ivan Maidanski + + * allchblk.c: Expand all tabs to spaces; remove trailing spaces at + EOLn; remove multiple trailing blank lines. + * mark.c: Ditto. + * mark_rts.c: Ditto. + * pthread_stop_world.c: Ditto. + * win32_threads.c: Ditto. + * include/gc.h: Ditto. + * include/private/gc_priv.h: Ditto. + * pthread_stop_world.c: Add copyright header. + * include/gc.h: Reformat some comments. + +2009-09-19 Ivan Maidanski + (ivmai130a.diff, ivmai130b.diff - superseding diff44, diff69) + + * include/gc.h (GC_do_blocking, GC_call_with_gc_active): New + function prototype. + * include/private/gc_priv.h (STOP_WORLD): Replace a no-op (for the + single-threaded case) with an assertion check for the state to be + not a "do-blocking" one. + * include/private/gc_priv.h (blocking_data): Move the structure + definition from pthread_support.c; change "fn" return type to void + pointer. + * include/private/gc_priv.h (GC_activation_frame_s): New structure + type. + * include/private/gc_priv.h (GC_push_all_stack_frames): New + function declaration (only if THREADS). + * include/private/gc_priv.h (GC_world_stopped): Don't declare + unless THREADS. + * include/private/gc_priv.h (GC_blocked_sp, + GC_activation_frame_s): New declaration (only if not THREADS). + * include/private/gc_priv.h (GC_push_all_register_frames): New + function declaration (only for IA-64). + * include/private/gc_priv.h (NURSERY, GC_push_proc): Remove + obsolete (unused) symbols. + * include/private/gc_priv.h (GC_push_all_stack_partially_eager): + Remove declaration (since it is static now). + * mark_rts.c (GC_push_all_stack_partially_eager): Move from mark.c + (for code locality) and make STATIC. + * mark_rts.c (GC_push_all_register_frames): New function (only for + IA-64). + * mark_rts.c (GC_push_all_stack_frames): New function (only if + THREADS). + * mark_rts.c (GC_add_trace_entry): New function prototype (used by + GC_push_all_stack_partially_eager(), only if TRACE_BUF). + * mark_rts.c (GC_push_all_stack_part_eager_frames): New function. + * mar_rts.c (GC_save_regs_ret_val): Move the declaration out of a + function body (only for IA-64). + * mark_rts.c (GC_push_current_stack): Call + GC_push_all_stack_part_eager_frames() instead of + GC_push_all_stack_partially_eager(). + * mark_rts.c (GC_push_current_stack): Call + GC_push_all_register_frames() instead of GC_push_all_eager() for + IA-64 backing store. + * misc.c (GC_do_blocking_inner): Declare function (if THREADS + only). + * misc.c (GC_blocked_sp, GC_blocked_register_sp, + GC_activation_frame): New global variables (only if not THREADS). + * misc.c (GC_call_with_gc_active, GC_do_blocking_inner): New API + function (only if not THREADS). + * misc.c (GC_do_blocking): Move the function from + pthread_support.c. + * include/private/pthread_support.h (GC_Thread_Rep): Add + "activation_frame" field. + * pthread_stop_world.c (GC_push_all_stacks): Call + GC_push_all_stack_frames() and GC_push_all_register_frames instead + of GC_push_all_stack() and/or GC_push_all_eager(); don't check for + STACK_GROWS_UP here. + * pthread_support.c (GC_do_blocking_inner): Remove "static"; store + "fn" result back to "client_data" field. + * pthread_support.c (GC_call_with_gc_active): New API function. + * win32_threads.c (GC_call_with_gc_active): Ditto. + * win32_threads.c (GC_Thread_Rep): Add "thread_blocked_sp" and + "activation_frame" fields. + * win32_threads.c (GC_new_thread): Add assertion checking for + thread_blocked_sp is NULL. + * win32_threads.c (GC_do_blocking_inner): New function. + * win32_threads.c (GC_stop_world): Don't suspend a thread if its + thread_blocked_sp is non-NULL. + * win32_threads.c (GC_push_stack_for): Use thread + "activation_frame" (if non-NULL); use "thread_blocked_sp" if + non-NULL (instead of calling GetThreadContext()); "UNPROTECT" the + thread before modifying its last_stack_min; call + GC_push_all_stack_frames() instead of GC_push_all_stack(); update + the comments. + +2009-09-19 Ivan Maidanski + (ivmai129.diff - superseding diff47) + + * alloc.c (GC_default_stop_func): New static variable (initialized + to GC_never_stop_func). + * alloc.c (GC_set_stop_func, GC_get_stop_func): New function. + * alloc.c (GC_timeout_stop_func): Define as GC_default_stop_func + (instead of GC_never_stop_func) if SMALL_CONFIG (or NO_CLOCK), + else call GC_default_stop_func() before getting "current_time". + * alloc.c (GC_maybe_gc): Expand GC_gcollect_inner() macro (for + FIXME comment). + * alloc.c (GC_maybe_gc, GC_collect_a_little_inner): add FIXME for + replacing GC_never_stop_func with GC_default_stop_func (if + possible). + * alloc.c (GC_gcollect): Use GC_default_stop_func. + * alloc.c (GC_collect_or_expand): Use GC_default_stop_func + (instead of GC_never_stop_func) unless it is trigged due to out of + memory; don't increment GC_fail_count and don't output warning + (before trying to collect again) in case the collection has been + interrupted (by GC_default_stop_func) and the heap expansion has + failed too. + * include/gc.h (GC_set_stop_func, GC_get_stop_func): New function + prototypes. + +2009-09-19 Ivan Maidanski + + * os_dep.c (GC_get_stack_base): Add FIXME; add assertion for + GC_get_writable_length() result. + +2009-09-18 Ivan Maidanski (really Ludovic Courtes) + + * configure.ac: Don't use -lpthread -ldl for Cygwin. + +2009-09-18 Ivan Maidanski + + * NT_THREADS_MAKEFILE: Make it back equal to gc.mak. + +2009-09-18 Ivan Maidanski + (ivmai142.diff) + + * include/private/gcconfig.h (GWW_VDB): Undefine if + USE_GLOBAL_ALLOC (since incompatible). + * os_dep.c (GetWriteWatch_alloc_flag): Define as 0 unless GWW_VDB + is defined. + * os_dep.c (GC_unmap_threshold): Declare (for use in + GC_init_win32) if USE_MUNMAP. + * os_dep.c (GC_init_win32): Turn off memory unmapping if + GlobalAlloc() is used. + * os_dep.c (GC_win32_get_mem): Define and use new + VIRTUAL_ALLOC_PAD macro; don't waste a extra memory page unless + MPROTECT_VDB is in use. + +2009-09-17 Ivan Maidanski + + * Makefile: Replace "version.h" with "include/gc_version.h". + * include/gc_version.h: Ditto. + +2009-09-17 Ivan Maidanski + + * alloc.c (GC_collect_or_expand): Output heap size in WARN() + (before returning FALSE) for convenience. + +2009-09-17 Ivan Maidanski + (ivmai139.diff) + + * allchblk.c (GC_allochblk_nth): Use GC_PRIdPTR in WARN() format + string. + * pthread_support.c (start_mark_threads, GC_thr_init): Ditto. + * win32_threads.c (GC_delete_thread): Ditto. + * include/private/gc_priv.h (GC_PRIdPTR): New macro. + * pthread_stop_world.c (GC_suspend_handler_inner): Remove + unnecessary cast for WARN argument. + * pthread_support.c (start_mark_threads): if pthread_create() + failed then don't try to create other marker threads and (after + printing a warning) adjust GC_markers and GC_parallel values; log + GC_markers value (possibly adjusted) after that. + +2009-09-16 Ivan Maidanski + (ivmai140.diff) + + * win32_threads.c (start_mark_threads): if pthread_create() is + failed then don't try to create other marker threads and (after + printing a warning) adjust GC_markers and GC_parallel values. + * win32_threads.c (mark_mutex_event, builder_cv, mark_cv): Move + the definition upper (to be visible in start_mark_threads()). + * win32_threads.c (start_mark_threads): if CreateThread() or + _beginthreadex() is failed then don't try to create other marker + threads and (after printing a warning) adjust GC_markers, + GC_parallel values, and destroy the event objects (either only + some for the uncreated threads if DONT_USE_SIGNALANDWAIT or all if + not a single thread is created). + * win32_threads.c (GC_thr_init): Log GC_markers value (possibly + adjusted) after start_mark_threads() call. + +2009-09-16 Ivan Maidanski + + * Makefile.am: Back remove "GC_" prefix for PTHREADS, + DARWIN_THREADS, WIN32_THREADS (for configure.ac). + +2009-09-16 Ivan Maidanski + + * ChangeLog: Remove trailing spaces at EOLn; insert blank lines + where missed. + * doc/README: Expand all tabs to spaces; remove trailing spaces at + EOLn; remove multiple trailing blank lines. + * doc/README.autoconf: Ditto. + * doc/README.DGUX386: Ditto. + * doc/README.environment: Ditto. + * doc/README.macros: Ditto. + * doc/README.win32: Ditto. + * tests/test.c: Ditto. + * tests/test_cpp.cc: Ditto. + * backgraph.c: Ditto. + * blacklst.c: Ditto. + * checksums.c: Ditto. + * darwin_stop_world.c: Ditto. + * dbg_mlc.c: Ditto. + * dyn_load.c: Ditto. + * finalize.c: Ditto. + * gc_dlopen.c: Ditto. + * gcj_mlc.c: Ditto. + * headers.c: Ditto. + * mach_dep.c: Ditto. + * malloc.c: Ditto. + * mallocx.c: Ditto. + * new_hblk.c: Ditto. + * obj_map.c: Ditto. + * ptr_chck.c: Ditto. + * real_malloc.c: Ditto. + * reclaim.c: Ditto. + * stubborn.c: Ditto. + * thread_local_alloc.c: Ditto. + * typd_mlc.c: Ditto. + * gc_cpp.cc: Ditto. + * include/gc_allocator.h: Ditto. + * include/gc_backptr.h: Ditto. + * include/gc_config_macros.h: Ditto. + * include/gc_cpp.h: Ditto. + * include/gc_gcj.h: Ditto. + * include/gc_inline.h: Ditto. + * include/gc_mark.h: Ditto. + * include/gc_pthread_redirects.h: Ditto. + * include/gc_typed.h: Ditto. + * include/gc_version.h: Ditto. + * include/javaxfc.h: Ditto. + * include/new_gc_alloc.h: Ditto. + * include/private/darwin_semaphore.h: Ditto. + * include/private/dbg_mlc.h: Ditto. + * include/private/gc_hdrs.h: Ditto. + * include/private/gc_locks.h: Ditto. + * include/private/gc_pmark.h: Ditto. + * include/private/gcconfig.h: Ditto. + * include/private/pthread_support.h: Ditto. + * include/private/thread_local_alloc.h: Ditto. + * darwin_stop_world.c: Add copyright header. + * include/gc_backptr.h: Ditto. + * include/gc_config_macros.h: Ditto. + * include/gc_pthread_redirects.h: Ditto. + * include/gc_version.h: Ditto. + * include/javaxfc.h: Ditto. + * include/private/darwin_semaphore.h: Ditto. + * include/private/pthread_support.h: Ditto. + * gc_cpp.cc: Make copyright header uniform across the package. + * include/gc_cpp.h: Ditto. + +2009-09-16 Ivan Maidanski (really Petter Urkedal) + (gc_config_h_6a.patch with a minor correction) + + * include/private/gc_priv.h: Change include of config.h to + private/config.h. + * include/private/gc_pmark.h: Ditto. + * gc_cpp.cc: Ditto. + * tests/test.c: Ditto. + * tests/test_cpp.cc: Include private/config.h (if HAVE_CONFIG_H); + undefine GC_BUILD. + +2009-09-16 Ivan Maidanski + (ivmai128.diff - superseding diff62, diff66 partly) + + * finalize.c (GC_general_register_disappearing_link): Return + GC_SUCCESS, GC_DUPLICATE, GC_NO_MEMORY (instead of 0, 1 and 2, + respectively). + * include/gc.h (GC_NO_MEMORY): New macro (defined as 2). + * include/gc.h (GC_register_disappearing_link, + GC_general_register_disappearing_link): Update the comment. + * typd_mlc.c (GC_calloc_explicitly_typed): Use GC_NO_MEMORY macro. + * finalize.c (GC_general_register_disappearing_link, + GC_register_finalizer_inner): Recalculate the hash table index + after GC_oom_fn succeeded (since the table may grow while not + holding the lock) and check again that the entry is still not in + the table (free the unused entry otherwise unless DBG_HDRS_ALL). + * finalize.c (GC_register_finalizer_inner): Initialize "hhdr" + local variable (to prevent a compiler warning). + * finalize.c (GC_register_finalizer_inner): Don't modify the data + pointed by "ocd" and "ofn" in GC_register_finalizer_inner() failed + (due to out of memory). + +2009-09-16 Ivan Maidanski + (ivmai124.diff - superseding diff67 partly) + + * alloc.c (GC_set_fl_marks, GC_clear_fl_marks): Transform loop to + suppress compiler "variable might be uninitialized" warnings. + +2009-09-16 Ivan Maidanski + (ivmai138.diff) + + * Makefile.direct (DONT_USE_SIGNALANDWAIT): Add the comment for. + * win32_threads.c (DONT_USE_SIGNALANDWAIT): Always define for + WinCE. + * win32_threads.c (THREAD_HANDLE): Cast Id (of DWORD type) to + HANDLE thru word type (to avoid a compiler warning) for WinCE. + * win32_threads.c (GC_marker_cv, GC_marker_Id): New static array + (only if DONT_USE_SIGNALANDWAIT). + * win32_threads.c (start_mark_threads): Initialize GC_marker_Id + and GC_marker_cv for each helper thread (only if + DONT_USE_SIGNALANDWAIT). + * win32_threads.c (GC_mark_mutex_state): New static variable (only + if DONT_USE_SIGNALANDWAIT). + * win32_threads.c (GC_mark_mutex_waitcnt, + signalObjectAndWait_func): Don't define if DONT_USE_SIGNALANDWAIT. + * win32_threads.c (GC_acquire_mark_lock, GC_release_mark_lock): + Use InterlockedExchange() over GC_mark_mutex_state (instead of + AO_fetch_and_add()) if DONT_USE_SIGNALANDWAIT. + * win32_threads.c (GC_wait_marker, GC_notify_all_marker): + Implement wait/broadcast primitives using Win32 multiple events + (one for each marker thread) if DONT_USE_SIGNALANDWAIT (instead of + using Win32 SignalObjectAndWait). + * win32_threads.c (GC_thr_init): Don't declare hK32 local + variable, don't check for GC_wnt, and don't initialize + signalObjectAndWait_func if DONT_USE_SIGNALANDWAIT. + +2009-09-16 Ivan Maidanski + (ivmai127.diff - superseding diff49) + + * alloc.c (GC_finish_collection): Call GC_print_finalization_stats + if GC_print_stats (after getting "done_time"). + * finalize.c (GC_old_dl_entries): New static variable (only if not + SMALL_CONFIG). + * finalize.c (GC_finalize): Save current GC_dl_entries value (only + if not SMALL_CONFIG). + * finalize.c (GC_print_finalization_stats): Define if and only if + not SMALL_CONFIG; use GC_old_dl_entries value; use GC_log_printf() + instead of GC_printf(); use "%lu" (instead of "%u") print format + specifier; use unsigned long type for "ready" counter (for LP64 + targets). + * misc.c (GC_dump): No longer call GC_print_finalization_stats() + here (since it is called from GC_finish_collection()). + * misc.c (STACKBASE): Remove unused macro undef (for NOSYS and + ECOS). + +2009-09-16 Ivan Maidanski + (ivmai134.diff) + + * alloc.c (GC_expand_hp): Replace GC_init_inner() call with + GC_init() one. + * malloc.c (GC_alloc_large, GC_generic_malloc_inner): Ditto. + * mallocx.c (GC_generic_malloc_many): Ditto. + * misc.c (GC_enable_incremental): Ditto. + * alloc.c (GC_expand_hp): Update the comment. + * mark.c (GC_obj_kinds): Ditto. + * win32_threads.c (GC_allow_register_threads): Ditto. + * private/gc_priv.h (GC_init_inner): Remove function declaration. + * misc.c (GC_init_inner): Replace with public GC_init(). + +2009-09-16 Ivan Maidanski + (ivmai126.diff) + + * gcj_mlc.c (GC_gcj_fake_mark_proc): New static function. + * gcj_mlc.c (GC_init_gcj_malloc): If mp is 0 then supply + GC_gcj_fake_mark_proc (aborting with the appropriate message) + instead. + +2009-09-16 Ivan Maidanski + (ivmai125.diff) + + * os_dep.c (GC_wince_get_mem): If VirtualAlloc() returns NULL (due + to out of memory) then don't increment GC_n_heap_bases and don't + call VirtualAlloc() again (with MEM_COMMIT). + * os_dep.c (GC_remap): Abort with a more informatory message if + VirtualAlloc() fails due to out of memory; update FIXME. + +2009-09-16 Ivan Maidanski + (ivmai132.diff - superseding diff41a, diff64, diff84 partly) + + * Makefile: Fix typo for msvc_dbg.c. + * Makefile.direct: Ditto. + * Makefile.am: Prefix PTHREADS, DARWIN_THREADS, WIN32_THREADS with + "GC_". + * Makefile.dj: Don't reference remove files (nursery.c, + gc_nursery.h, gc_copy_descr.h). + * NT_MAKEFILE: Don't define __STDC__ macro (no longer used). + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_THREADS_MAKEFILE: Ditto. + * gc.mak: Ditto. + * NT_MAKEFILE: Remove unnecessary -DGC_BUILD (since it is always + defined in the source files). + * NT_THREADS_MAKEFILE: Ditto. + * NT_X64_THREADS_MAKEFILE: Ditto. + * gc.mak: Ditto. + * NT_X64_THREADS_MAKEFILE: Fix typo for -DGC_NOT_DLL. + * NT_STATIC_THREADS_MAKEFILE: Replace GC_WIN32_THREADS with + GC_THREADS. + * NT_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_THREADS_MAKEFILE: Ditto. + * gc.mak: Ditto. + * NT_MAKEFILE: Define _CRT_SECURE_NO_DEPRECATE to suppress the + compiler warnings. + * NT_STATIC_THREADS_MAKEFILE: Ditto. + * NT_X64_STATIC_THREADS_MAKEFILE: Place -D_CRT_SECURE_NO_DEPRECATE + before "$*.C" (and "$*.CPP"). + * NT_X64_THREADS_MAKEFILE: Ditto. + +2009-09-16 Ivan Maidanski + (ivmai131.diff - superseding diff83, diff84 partly) + + * doc/README.solaris2: Replace GC_SOLARIS_THREADS with GC_THREADS. + * doc/README.win32: Replace GC_WIN32_THREADS with GC_THREADS. + * doc/README.win64: Add info about mingw-w64; add note for VC++ + warnings suppression. + +2009-09-15 Hans Boehm (Mostly Juan Jose Garcia-Ripoll) + (Also similar to, but not the same as, Ivan's diff104_cvs) + + * os_dep.c (GC_forward_exception): Fix logic in several places. + (OSX-specific) + +2009-09-15 Ivan Maidanski + (ivmai137v2.diff) + + * include/private/gc_priv.h (MAX_HEAP_SECTS): Guard with ifndef. + +2009-09-14 Ivan Maidanski + (ivmai136v2.diff) + + * Makefile.direct: Copy missing information for -DSHORT_DBG_HDRS + from Makefile. + * Makefile: Remove the information about "define arguments" (which + is incomplete and outdated compared to that in Makefile.direct); + add help reference to Makefile.direct. + * Makefile.dj: Ditto. + +2009-09-14 Ivan Maidanski + (ivmai135.diff) + + * alloc.c (world_stopped_total_time, world_stopped_total_divisor): + Replace "STATIC" with "static" in the definition (since the + symbols aren't prefixed with "GC_"). + * win32_threads.c (marker_sp, marker_bsp, marker_last_stack_min, + start_mark_threads, mark_mutex, builder_cv, mark_cv, + mark_mutex_event, signalObjectAndWait_func, main_thread_start): + Ditto. + * pthread_support.c (GC_wait_builder): Define as STATIC. + * win32_threads.c (GC_wait_builder): Ditto. + +2009-09-14 Ivan Maidanski + (ivmai133.diff) + + * misc.c (GC_get_heap_size_inner, GC_get_free_bytes_inner): New + API function. + * include/gc_pmark.h (GC_get_heap_size_inner, + GC_get_free_bytes_inner): New function declaration. + +2009-09-10 Ivan Maidanski + (ivmai121.diff) + + * include/gc.h: Recognize __CEGCC__ (as a synonym for _WIN32_WCE). + * include/gc_config_macros.h: Ditto. + * include/gc.h (GC_MAXIMUM_HEAP_SIZE): Recognize new macro. + * include/gc.h (GC_INIT_CONF_MAXIMUM_HEAP_SIZE): New macro (for + internal use). + * include/gc_config_macros.h: Always include stddef.h if GCC. + * include/gc_config_macros.h (GC_API): Define for CeGCC in the + same way as for MinGW. + * include/gc_config_macros.h (GC_API): Group the definition for + all cases together (check for GC_DLL only once). + * include/gc_pthread_redirects.h: Group non-Darwin code together. + * tests/test.c: Recognize GC_PRINT_VERBOSE_STATS (only if GC_DLL). + +2009-09-10 Ivan Maidanski + (ivmai120a.diff, ivmai120b.diff) + + * Makefile.direct (GC_PTHREADS_PARAMARK, GC_IGNORE_GCJ_INFO, + GC_PRINT_VERBOSE_STATS, GC_DONT_EXPAND, GC_INITIAL_HEAP_SIZE, + GC_FREE_SPACE_DIVISOR, GC_TIME_LIMIT, GC_FULL_FREQ): Add the + comment for. + * misc.c (GC_init_inner): Recognize GC_PRINT_VERBOSE_STATS (new + macro). + * dyn_load.c (GC_wnt): Change definition to TRUE for WinCE; add + FIXME and the comment for WinCE. + * gcj_mlc.c (GC_init_gcj_malloc): Recognize GC_IGNORE_GCJ_INFO + (new macro). + * include/gc.h (GC_HAVE_BUILTIN_BACKTRACE): Don't define for VC++ + WinCE (since backtrace() is unimplemented). + * include/private/gc_priv.h (GC_n_heap_bases): Remove declaration + (since static). + * os_dep.c (GC_n_heap_bases): Define as STATIC; move the + definition to be above GC_is_heap_base(). + * include/private/gcconfig.h: Don't define NOSYS for WinCE on ARM + (both for MinGW and CeGCC toolchains). + * include/private/gcconfig.h: Recognize __CEGCC__ and + __MINGW32CE__ (as synonyms for __WIN32_WCE). + * include/private/gcconfig.h: If SH4 then don't set config + parameters for SH. + * include/private/thread_local_alloc.h (GC_key_create): Don't + abort on failures, just return -1 in these cases (this also + prevents compilation error for targets where ABORT is defined + indirectly as an inline assembler sequence). + * mark.c (WRAP_MARK_SOME): Also define for WinCE; add FIXME for + the GCC-based cross-compiler. + * mark.c (ext_ex_regn, mark_ex_handler): Don't define unless + WRAP_MARK_SOME is defined; define also for WinCE case; don't + check for _WIN64 (since WRAP_MARK_SOME is undefined for it). + * mark.c (GC_mark_some): Use __try/__except also for WinCE; update + the comment. + * misc.c: Include signal.h after gc_pmark.h included; check for + MSWINCE instead of _WIN32_WCE. + * misc.c (GC_init_inner): Remove duplicate GC_setpagesize() call. + * misc.c: Don't include for WinCE targets. + * misc.c (GC_write): Define _MAX_PATH if undefined (workaround for + CeGCC toolchain). + * misc.c (GC_write): Use OutputDebugStringW() instead of + _CrtDbgReport() for WinCE targets. + * os_dep.c (GC_least_described_address): Define as STATIC. + * os_dep.c (GC_register_data_segments): Fix code indentation. + * os_dep.c (GC_wince_get_mem): Initialize "result" local variable + (to prevent a compiler warning). + * os_dep.c (GC_dirty_init): Add comment for WinCE target. + * tests/test.c: Don't include winbase.h directly if GCC for WinCE, + include assert.h instead. + * tests/test.c (tiny_reverse_test): Define and use + TINY_REVERSE_UPPER_VALUE macro (4 if VERY_SMALL_CONFIG else 10); + useful for WinCE. + * win32_threads.c (GC_Thread_Rep): Don't declare "handle" field + for WinCE (since thread Id is used as a "real" thread handle). + * win32_threads.c (THREAD_HANDLE): New macro. + * win32_threads.c (GC_register_my_thread_inner): Don't recognize + DONT_IMPORT_GETCURTHREAD anymore; don't record thread handle on + WinCE. + * Makefile.direct (DONT_IMPORT_GETCURTHREAD): Remove comment for. + * win32_threads.c (UNPROTECT, GC_fault_handler_lock): Don't check + for MSWINCE. + * win32_threads.c (GC_delete_gc_thread, GC_delete_thread): Don't + close thread handle on WinCE (since it's a thread Id). + * win32_threads.c (GC_suspend): Don't check for MSWINCE in the + MPROTECT-related code (for the case if MPROTECT_VDB would be + implemented for WinCE). + * win32_threads.c (GC_suspend, GC_start_world, GC_push_stack_for): + Use THREAD_HANDLE(t) to obtain thread handle. + * win32_threads.c (GC_PTHREADS_PARAMARK): New macro recognized; + implicitly define GC_PTHREADS_PARAMARK if GC_PTHREADS; include + pthread.h; define NUMERIC_THREAD_ID(id) if undefined yet; replace + GC_PTHREADS with GC_PTHREADS_PARAMARK where appropriate (for the + parallel mark support). + * win32_threads.c (start_mark_threads): Use int type for "i" local + variable (instead of "unsigned") to prevent a compiler warning. + * win32_threads.c (start_mark_threads): Don't check CreateThread() + result for -1; call CloseHandle() for the handle created by + CreateThread() (on WinCE); don't use errno (since errno.h is + missing on some targets like WinCE) when printing warning on a + marker thread creation failure. + * win32_threads.c (signalObjectAndWait_func): Define for WinCE. + * win32_threads.c (GC_wait_marker): Remove unnecessary assertion + for non-zero signalObjectAndWait_func (to make the code compilable + for WinCE). + * win32_threads.c (GC_thr_init): Allow PARALLEL_MARK for WinCE; + use GC_sysinfo to get processors count if WinCE; don't check for + SignalObjectAndWait() if WinCE; replace GC_PTHREADS with + GC_PTHREADS_PARAMARK. + * win32_threads.c (GC_thr_init): Recognize GC_MIN_MARKERS new + macro (useful for testing parallel marking on WinCE). + * win32_threads.c (GC_win32_start, main_thread_start): Define as + STATIC. + * win32_threads.c: Don't define main_thread_args, + main_thread_start(), WinMain() for WinCE if GC_DLL. + * win32_threads.c (WINCE_MAIN_STACK_SIZE): Remove useless macro + (since the stack size parameter is ignored on WinCE). + * win32_threads.c (main_thread_start): Remove forward declaration; + place its definition before WinMain() one. + * win32_threads.c (WinMain): Abort if GC_CreateThread() or + WaitForSingleObject() failed (for the main thread). + +2009-09-10 Ivan Maidanski + (diff118_cvs - superseding diff53) + + * allchblk.c (MUNMAP_THRESHOLD): Move macro definition out of + a function. + * allchblk.c (GC_unmap_threshold): New global variable definition + (initialized to MUNMAP_THRESHOLD). + * allchblk.c (GC_unmap_old): Use GC_unmap_threshold instead of + MUNMAP_THRESHOLD; skip unmapping if GC_unmap_threshold is 0. + * doc/README.environment (GC_UNMAP_THRESHOLD): Add information. + * misc.c (GC_unmap_threshold): New variable declaration. + * misc.c (GC_init_inner): Recognize "GC_UNMAP_THRESHOLD" + environment variable to set GC_unmap_threshold value (only if + USE_MUNMAP). + +2009-09-10 Ivan Maidanski + (diff117) + + * dbg_mlc.c (OFN_UNSET): New macro (to detect + GC_register_finalizer() failures). + * dbg_mlc.c (store_old): Add a check for register_finalizer() + failure caused by an out-of-memory event (leave *ofn and *ocd + unmodified in that case). + * dbg_mlc.c (GC_debug_register_finalizer, + GC_debug_register_finalizer_no_order, + GC_debug_register_finalizer_unreachable, + GC_debug_register_finalizer_ignore_self): Initialize my_old_fn + to OFN_UNSET; clear *ocd and *ofn for non-heap objects (the same + as in GC_register_finalizer_inner()). + +2009-09-10 Ivan Maidanski + (diff116a, diff116b, diff116c) + + * Makefile.direct (GC_DLL): Add the comment for. + * doc/README.macros: Fix a typo. + * doc/README.macros (_DLL, GC_DLL, GC_NOT_DLL): Update info. + * doc/README.macros (__STDC__): Remove info. + * dbg_mlc.c (GC_get_back_ptr_info, GC_generate_random_heap_address, + GC_generate_random_valid_address, GC_print_backtrace, + GC_generate_random_backtrace, GC_register_describe_type_fn): Add + GC_API and GC_CALL to function definition. + * malloc.c (GC_generic_malloc): Ditto. + * mallocx.c (GC_incr_bytes_allocd, GC_incr_bytes_freed): Ditto. + * mark.c (GC_mark_and_push): Ditto. + * misc.c (GC_new_free_list_inner, GC_new_free_list, + GC_new_kind_inner, GC_new_kind, GC_new_proc_inner, GC_new_proc): + Ditto. + * include/gc_backptr.h (GC_get_back_ptr_info, + GC_generate_random_heap_address, GC_generate_random_valid_address, + GC_generate_random_backtrace, GC_print_backtrace): Add GC_API and + GC_CALL to function prototype. + * include/gc_mark.h (GC_mark_and_push, GC_new_free_list, + GC_new_free_list_inner, GC_new_kind, GC_new_kind_inner, + GC_new_proc, GC_new_proc_inner, GC_generic_malloc, + GC_register_describe_type_fn): Ditto. + * include/new_gc_alloc.h (GC_incr_bytes_allocd, GC_incr_mem_freed, + GC_generic_malloc_words_small): Ditto. + * gc_cpp.cc: Include "config.h" (if HAVE_CONFIG_H defined). + * include/private/gc_pmark.h: Ditto. + * include/private/gc_priv.h: Ditto. + * tests/test.c: Ditto. + * gc_cpp.cc: Define GC_BUILD. + * include/private/gc_pmark.h: Ditto. + * include/private/gc_priv.h: Ditto. + * gc_dlopen.c (WRAP_FUNC, REAL_FUNC): New macro. + * gc_dlopen.c (dlopen): Add GC_API to the wrapper function + definition. + * pthread_support.c (GC_pthread_create, GC_pthread_sigmask, + GC_pthread_join, GC_pthread_detach, pthread_sigmask, pthread_join, + pthread_detach, pthread_create): Ditto. + * win32_threads.c (GC_pthread_join, GC_pthread_create, + GC_pthread_sigmask, GC_pthread_detach): Ditto. + * gc_dlopen.c (dlopen): Use WRAP_FUNC and REAL_FUNC macros. + * include/gc_backptr.h: Include "gc.h". + * include/gc_backptr.h: Use extern "C" for the exported functions. + * include/gc_mark.h: Ditto. + * include/gc_config_macros.h (GC_THREADS): Define the macro if any + GC_XXX_THREADS is defined. + * include/gc_config_macros.h (_PTHREADS, _POSIX4A_DRAFT10_SOURCE): + Move the definitions below the place where GC_NETBSD_THREADS and + GC_DGUX386_THREADS are defined. + * include/gc_config_macros.h (GC_DLL): Don't define (even if _DLL + is defined) for GCC. + * include/gc_config_macros.h (GC_API): Define for Cygwin (in the + same way as for VC++); define for GCC v4+ (other than already + recognized MinGW/Cygwin) as a "default" visibility attribute if + GC_DLL is defined. + * include/gc_config_macros.h (GC_ATTR_MALLOC, GC_ATTR_ALLOC_SIZE): + New macro. + * include/gc.h (GC_malloc, GC_malloc_atomic, GC_strdup, + GC_malloc_uncollectable, GC_malloc_stubborn, GC_memalign, + GC_malloc_atomic_uncollectable, GC_malloc_ignore_off_page, + GC_malloc_atomic_ignore_off_page, GC_debug_malloc, + GC_debug_malloc_atomic, GC_debug_strdup, + GC_debug_malloc_uncollectable, GC_debug_malloc_stubborn, + GC_debug_malloc_ignore_off_page, + GC_debug_malloc_atomic_ignore_off_page, + GC_debug_malloc_replacement): Add GC_ATTR_MALLOC attribute. + * include/gc_gcj.h (GC_gcj_malloc, GC_debug_gcj_malloc, + GC_gcj_malloc_ignore_off_page): Ditto. + * include/gc.h (GC_malloc, GC_malloc_atomic, + GC_malloc_uncollectable, GC_malloc_stubborn, + GC_malloc_atomic_uncollectable, GC_malloc_ignore_off_page, + GC_malloc_atomic_ignore_off_page, GC_debug_malloc, + GC_debug_malloc_atomic, GC_debug_malloc_uncollectable, + GC_debug_malloc_stubborn, GC_debug_malloc_ignore_off_page, + GC_debug_malloc_atomic_ignore_off_page, + GC_debug_malloc_replacement: Add GC_ATTR_ALLOC_SIZE attribute + (for the first argument). + * include/gc_gcj.h (GC_gcj_malloc, GC_debug_gcj_malloc, + GC_gcj_malloc_ignore_off_page): Ditto. + * include/gc.h (GC_memalign, GC_realloc, GC_debug_realloc, + GC_debug_realloc_replacement): Add GC_ATTR_ALLOC_SIZE attribute + (for the second argument). + * include/gc.h (GC_malloc, GC_malloc_atomic, GC_strdup, + GC_malloc_uncollectable, GC_malloc_stubborn, GC_memalign, + GC_malloc_atomic_uncollectable, GC_free, GC_base, GC_size, + GC_realloc, GC_expand_hp, GC_set_max_heap_size, + GC_exclude_static_roots, GC_add_roots, GC_remove_roots, + GC_register_displacement, GC_debug_register_displacement, + GC_try_to_collect, GC_malloc_ignore_off_page, + GC_malloc_atomic_ignore_off_page, GC_debug_malloc, + GC_debug_malloc_atomic, GC_debug_strdup, + GC_debug_malloc_uncollectable, GC_debug_malloc_stubborn, + GC_debug_malloc_ignore_off_page, + GC_debug_malloc_atomic_ignore_off_page, GC_debug_free, + GC_debug_realloc, GC_debug_malloc_replacement, + GC_debug_realloc_replacement, GC_finalization_proc, + GC_register_finalizer, GC_debug_register_finalizer, + GC_register_finalizer_ignore_self, + GC_debug_register_finalizer_ignore_self, + GC_register_finalizer_no_order, + GC_debug_register_finalizer_no_order, + GC_register_finalizer_unreachable, + GC_debug_register_finalizer_unreachable, + GC_register_disappearing_link, + GC_general_register_disappearing_link, + GC_unregister_disappearing_link, GC_noop1, GC_warn_proc, + GC_set_warn_proc, GC_ignore_warn_proc, GC_fn_type, + GC_call_with_alloc_lock, GC_stack_base_func, + GC_call_with_stack_base, GC_same_obj, GC_pre_incr, GC_post_incr, + GC_is_visible, GC_is_valid_displacement, GC_same_obj_print_proc, + GC_is_valid_displacement_print_proc, GC_is_visible_print_proc, + GC_malloc_many, GC_CreateThread, GC_beginthreadex, + GC_endthreadex): Comment out (or remove if single and meaningless) + function argument names (to avoid identifiers out of the name + space). + * include/gc_gcj.h (GC_init_gcj_malloc, GC_gcj_malloc, + GC_debug_gcj_malloc, GC_gcj_malloc_ignore_off_page): Ditto. + * include/gc.h (GC_try_to_collect): Update the comment. + * include/gc.h (GC_size, GC_register_my_thread): Add const + qualifier for the argument referent. + * misc.c (GC_size): Ditto. + * pthread_support.c (GC_register_my_thread_inner, + GC_register_my_thread): Ditto. + * win32_threads.c (GC_register_my_thread_inner, + GC_register_my_thread): Ditto. + * include/gc.h (GC_INIT_CONF_ROOTS): New macro for internal use + (define instead of GC_INIT() for Cygwin and AIX). + * include/gc.h (GC_DONT_EXPAND, GC_MAX_RETRIES, + GC_FREE_SPACE_DIVISOR, GC_FULL_FREQ, GC_TIME_LIMIT, GC_IGNORE_WARN, + GC_INITIAL_HEAP_SIZE): Recognize new macro. + * include/gc.h (GC_INIT_CONF_DONT_EXPAND, GC_INIT_CONF_MAX_RETRIES, + GC_INIT_CONF_FREE_SPACE_DIVISOR, GC_INIT_CONF_FULL_FREQ, + GC_INIT_CONF_TIME_LIMIT, GC_INIT_CONF_IGNORE_WARN, + GC_INIT_CONF_INITIAL_HEAP_SIZE): New macro for internal use. + * include/gc.h (GC_INIT): Use GC_INIT_CONF_XXX macros. + * include/gc_mark.h: Prefix GC_H with '_'. + * include/gc_mark.h (GC_least_plausible_heap_addr, + GC_greatest_plausible_heap_addr, GC_debug_header_size): Use GC_API + for the public variable declaration. + * include/new_gc_alloc.h (GC_objfreelist_ptr, GC_aobjfreelist_ptr, + GC_uobjfreelist_ptr, GC_auobjfreelist_ptr): Ditto. + * include/gc_pthread_redirects.h (GC_pthread_create, + GC_pthread_sigmask, GC_dlopen, GC_pthread_join, GC_pthread_detach): + Use GC_API for the wrapper prototype. + * include/gc_pthread_redirects.h (pthread_create, pthread_join, + pthread_detach, pthread_sigmask, dlopen): Undefine unconditionally + before redirecting. + * include/new_gc_alloc.h: Replace GC_incr_mem_freed() with + GC_incr_bytes_freed(); remove FIXME. + * include/private/gc_priv.h (GC_make_closure, + GC_debug_invoke_finalizer, GC_noop): Remove GC_API for the private + function. + * tests/test.c (GC_print_stats): Handle GC_DLL case regardless of + the target. + +2009-09-10 Ivan Maidanski + (diff115) + + * finalize.c (GC_general_register_disappearing_link, + GC_register_finalizer_inner): Remove unnecessary "ifdef THREADS" + guard for LOCK/UNLOCK(). + * finalize.c (GC_general_register_disappearing_link, + GC_register_finalizer_inner): Get GC_oom_fn value before releasing + the lock (to prevent data races). + * gcj_mlc.c (GC_gcj_malloc, GC_debug_gcj_malloc, + GC_gcj_malloc_ignore_off_page): Ditto. + * mallocx.c (GC_generic_malloc_ignore_off_page): Ditto. + * include/gc_inline.h (GC_FAST_MALLOC_GRANS): Use GC_get_oom_fn() + instead of GC_oom_fn (to prevent data races). + * malloc.c (GC_generic_malloc): Ditto. + * mallocx.c (GC_memalign): Ditto. + * pthread_support.c (pthread_create): Ditto. + * gcj_mlc.c (maybe_finalize): Acquire the lock before setting + last_finalized_no value to prevent data races. + * include/gc.h (GC_gc_no, GC_get_gc_no, GC_oom_fn, GC_set_oom_fn, + GC_set_find_leak, GC_set_finalize_on_demand, + GC_set_java_finalization, GC_set_finalizer_notifier, + GC_set_dont_expand, GC_set_full_freq, GC_set_non_gc_bytes, + GC_set_no_dls, GC_set_free_space_divisor, GC_set_max_retries, + GC_set_dont_precollect, GC_set_time_limit, GC_warn_proc): Refine + the comment. + * misc.c (GC_set_oom_fn): Ditto. + * include/gc.h (GC_general_register_disappearing_link): Refine the + comment (replace "soft" word with "weak"). + * misc.c (GC_oom_fn, GC_get_gc_no, GC_get_parallel, + GC_set_finalizer_notifier, GC_set_find_leak): Add the comment. + * misc.c (GC_set_oom_fn, GC_get_oom_fn, GC_set_finalizer_notifier, + GC_get_finalizer_notifier): Use LOCK/UNLOCK to prevent data races. + +2009-09-10 Ivan Maidanski + (diff114a, diff114b, diff114c) + + * dbg_mlc.c: Guard include with ifndef MSWINCE; include + "private/dbg_mlc.h" before it. + * malloc.c: Ditto. + * dbg_mlc.c (GC_debug_strdup): Use memcpy() instead of strcpy() + for WinCE (since deprecated); evaluate strlen() only once; don't + set errno for WinCE. + * malloc.c (GC_strdup): Ditto. + * dyn_load.c (GC_wnt): Define as macro (FALSE) for WinCE. + * include/gc.h (GC_unregister_my_thread): Refine the comment. + * include/gc.h (GC_uintptr_t, GC_beginthreadex, GC_endthreadex): + Don't declare for WinCE. + * include/gc.h (GC_WINMAIN_WINCE_LPTSTR): New macro (WinCE only). + * include/gc.h (GC_WinMain): Remove GC_API. + * include/gc.h (GC_WinMain): Use GC_WINMAIN_WINCE_LPTSTR for + lpCmdLine. + * tests/test.c (GC_WinMain): Ditto. + * win32_threads.c (main_thread_args, GC_WinMain): Ditto. + * include/gc_config_macros.h (ptrdiff_t): Guard with + ifndef _PTRDIFF_T_DEFINED; define _PTRDIFF_T_DEFINED macro. + * include/private/gc_locks.h: Guard include "atomic_ops.h" with + ifdef GC_PTHREADS (and not GC_WIN32_THREADS). + * mark.c: Include "atomic_ops.h" if PARALLEL_MARK. + * thread_local_alloc.c: Include "atomic_ops.h" if GC_GCJ_SUPPORT. + * win32_threads.c: Include "atomic_ops.h" if MPROTECT_VDB. + * include/private/gc_locks.h: Use include "atomic_ops.h" instead + of include . + * include/private/gc_priv.h: Ditto. + * include/private/gc_locks.h (GC_allocate_ml, GC_need_to_lock): + Don't export (replace GC_API to "extern"). + * win32_threads.c (GC_allocate_ml): Don't export. + * include/private/gc_priv.h (DebugBreak): Define as macro for + WinCE (if not UNDER_CE and DebugBreak is not defined yet). + * include/private/gc_priv.h (UNALIGNED): Rename to UNALIGNED_PTRS + (since "UNALIGNED" is defined in winnt.h of WinCE). + * mark.c (UNALIGNED): Ditto. + * include/private/gcconfig.h (ARM32): Recognize _M_ARM and _ARM_. + * include/private/gcconfig.h (ALIGNMENT): Check always defined. + * include/private/gcconfig.h: Allow GC_WIN32_THREADS for WinCE. + * include/private/thread_local_alloc.h: Define USE_WIN32_SPECIFIC + for WinCE (since __declspec(thread) is unsupported). + * include/private/thread_local_alloc.h (TLS_OUT_OF_INDEXES): + Define for WinCE (if undefined). + * malloc.c (GC_malloc): Remove outdated comment about disabling + signals. + * misc.c: Don't include (since not used anymore and may + break TEXT() macro defined in winnt.h). + * misc.c (GC_init_inner): Don't use GetModuleHandle() and + InitializeCriticalSectionAndSpinCount() for WinCE. + * misc.c (GC_init_inner): Replace GetModuleHandleA() with + GetModuleHandle() (and use TEXT() macro controlled by UNICODE). + * misc.c (LOG_FILE): Remove unused macro; don't use _T() macro. + * misc.c (GC_CreateLogFile): New static function (Win32/WinCE + only); move the code from GC_write(); replace GETENV() with + GetEnvironmentVariable(); replace CreateFileA() with + CreateFile(); use TEXT() macro (for Unicode support); replace + strcat() with memcpy() (since deprecated in WinCE). + * misc.c (GC_write): Define as STATIC. + * win32_threads.c (GC_attached_thread): Ditto. + * misc.c (GC_write): Use GC_CreateLogFile(). + * misc.c: Define vsnprintf macro as StringCchVPrintfA for WinCE. + * misc.c (GC_abort): Try to invoke MessageBoxA() dynamically + (Win32 only) if DONT_USE_USER32_DLL is defined. + * misc.c (GC_abort): Duplicate msg to GC log file (for Win32 and + WinCE). + * misc.c (GC_abort): Use a more user-friendly abort if + NO_DEBUGGING (Win32 only). + * os_dep.c: Include "atomic_ops.h" only if MPROTECT_VDB (and + THREADS). + * os_dep.c (detect_GetWriteWatch): Use TEXT() for GetModuleHandle + (for Unicode support); check GetModuleHandle() result. + * tests/test.c: Don't define assert for WinCE (since may be + redefined by "assert.h" included from libatomic_ops). + * tests/test.c (FAIL): Define as ABORT for all targets (except + for PCR). + * tests/test.c (n_tests): Don't use AO_t. + * tests/test.c (check_heap_stats): Don't cast n_tests. + * tests/test.c (inc_int_counter): New function (for n_tests atomic + incrementation). + * tests/test.c (run_one_test): Test GC_memalign() for all targets. + * tests/test.c (run_one_test): Avoid unbalanced brackets in + #if-#else-#endif blocks. + * tests/test.c (run_one_test): Replace AO_fetch_and_add1() and + private LOCK/UNLOCK with GC_call_with_alloc_lock(inc_int_counter). + * tests/test.c (check_heap_stats): Replace + "if (sizeof(char *) > 4)" with "#if CPP_WORDSZ == 64" to suppress + "unreachable code" compiler warning. + * tests/test.c (WinMain): Set cmd type to LPWSTR (for WinCE + "UNDER_CE" mode); else use LPSTR type (for Win32 and WinCE). + * tests/test.c (thr_window): Replace "L" string prefix with + TEXT(). + * thread_local_alloc.c: Check THREADS is defined (to prevent other + compiler errors and warnings otherwise). + * tests/test.c (WinMain): Recognize GC_NO_DLLMAIN macro (for + GC_use_DllMain()). + * Makefile.direct (GC_NO_DLLMAIN, DONT_IMPORT_GETCURTHREAD): Add + the comments for. + * win32_threads.c (GC_register_my_thread_inner): Recognize + DONT_IMPORT_GETCURTHREAD macro. + * win32_threads.c: Recognize GC_NO_DLLMAIN macro (to exclude + DllMain support if needed). + * win32_threads.c (GC_NO_DLLMAIN): Define implicitly if DllMain + thread registration is unsupported for a given configuration. + * win32_threads.c (GC_use_DllMain): Update the comment; refine + ABORT message. + * win32_threads.c (GC_use_DllMain, + GC_started_thread_while_stopped, GC_register_my_thread_inner, + GC_lookup_thread_inner, GC_delete_gc_thread, + GC_allow_register_threads, GC_lookup_pthread, + GC_push_thread_structures, GC_stop_world, GC_push_all_stacks): + Check for GC_NO_DLLMAIN. + * win32_threads.c (GC_Thread_Rep.tm_in_use, GC_attached_thread, + DllMain): Don't define if GC_NO_DLLMAIN. + * win32_threads.c (GC_stop_world): Declare "i" and "max" local + variables only if not GC_NO_DLLMAIN (to suppress compiler + warning). + * win32_threads.c (GC_mark_thread, start_mark_threads): Use + CreateThread() instead of _beginthreadex() for WinCE. + * win32_threads.c (MARK_THREAD_STACK_SIZE, WINCE_MAIN_STACK_SIZE): + New macros defined (used by start_mark_threads(), WinMain()). + * win32_threads.c (GC_thr_init): Exclude parallel-specific code on + WinCE for now (since getenv(), GetProcessAffinityMask() and + SignalObjectAndWait() are missing on WinCE). + * win32_threads.c (GC_thr_init): replace GetModuleHandleA() with + GetModuleHandle(); replace CreateEventA() with CreateEvent(); use + TEXT() macro (for Unicode support). + +2009-09-10 Ivan Maidanski + (diff113) + + * include/gc.h (GC_has_static_roots_func): New typedef (user filter + callback). + * include/gc.h (GC_register_has_static_roots_callback): Use + GC_has_static_roots_func type. + * dyn_load.c (GC_has_static_roots, + GC_register_has_static_roots_callback): Ditto. + * dyn_load.c (GC_has_static_roots, + GC_register_has_static_roots_callback): Define on all platforms. + * dyn_load.c (GC_register_dynlib_callback, + GC_register_dynamic_libraries, GC_init_dyld): Replace K&R-style + functions definition with the ANSI C one. + * dyn_load.c (GC_register_dynlib_callback): Use new local variable + "callback" (initialized from GC_has_static_roots) to minimize data + races. + * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr, + GC_cond_add_roots): Define as STATIC. + * mark_rts.c (GC_remove_roots_inner): Ditto. + * dyn_load.c (GC_dyld_image_add): Don't call GC_add_roots() for + sections smaller than pointer size (just to avoid acquiring the + lock unnecessarily). + * dyn_load.c (GC_dyld_name_for_hdr): Define unconditionally (not + only for DARWIN_DEBUG). + * dyn_load.c (GC_dyld_image_add): Replace GC_add_roots() call with + LOCK + GC_add_roots_inner() + UNLOCK. + * dyn_load.c (GC_dyld_image_add): Call GC_has_static_roots() user + callback (if set) holding the lock; if it returns 0 then don't call + GC_add_roots_inner() for that region. + * dyn_load.c (GC_register_has_static_roots_callback): Put + "callback" value to GC_has_static_roots on all platforms. + * dyn_load.c (GC_has_static_roots): Update the comments. + * include/gc.h (GC_exclude_static_roots, GC_add_roots, + GC_remove_roots, GC_register_has_static_roots_callback): Ditto. + * include/private/gc_priv.h (struct roots): Ditto. + * include/private/gc_priv.h (GC_remove_roots_inner): Move prototype + to mark_rts.c and declare it as STATIC. + * include/private/gc_priv.h (GC_exclude_static_roots_inner): New + prototype. + * dyn_load.c (GC_register_dynamic_libraries_dl_iterate_phdr): Use + GC_exclude_static_roots_inner() instead of GC_exclude_static_roots. + * misc.c (GC_init_inner): Ditto. + * mark_rts.c (GC_exclude_static_roots_inner): New function (move + all the code from GC_exclude_static_roots(); add the comment. + * mark_rts.c (GC_add_roots_inner, GC_exclude_static_roots_inner): + add alignment assertion for the lower bound; add assertion for the + lower bound to be less than the upper one. + * mark_rts.c (GC_add_roots_inner, GC_exclude_static_roots): Adjust + the upper bound (round down to be of a pointer-aligned value); + return in case of an empty range. + * mark_rts.c (GC_exclude_static_roots): Acquire the lock and call + GC_exclude_static_roots_inner(). + * mark_rts.c (GC_remove_roots): Quickly check the bounds and return + in case of a do-nothing case (before acquiring the lock). + +2009-09-10 Ivan Maidanski + (diff112) + + * finalize.c (GC_fail_count): New external variable declaration. + * finalize.c (GC_reset_finalizer_nested, + GC_check_finalizer_nested): New function declarations (if THREADS + only). + * finalize.c (GC_finalizer_nested, GC_finalizer_skipped): New + static global variables (used internally by GC_finalize() and + GC_check_finalizer_nested()). + * finalize.c (GC_check_finalizer_nested): New static function + definition (only if not THREADS, used internally by + GC_notify_or_invoke_finalizers() to minimize the probability of + a deep recursion when a client finalizer tries to allocate GC + memory). + * finalize.c (GC_finalize): Reset GC_finalizer_nested value (or + call GC_reset_finalizer_nested()) if last heap expansion failed. + * finalize.c (GC_notify_or_invoke_finalizers): Access GC_gc_no, + GC_finalizer_now, GC_finalize_on_demand, GC_finalizer_notifier, + last_finalizer_notification variables holding the lock (to avoid + data races). + * finalize.c (GC_finalizer_notifier): Add comment. + * finalize.c (GC_notify_or_invoke_finalizers): Add "quick" check + for an empty finalization queue (only if THREADS and not + KEEP_BACK_PTRS/MAKE_BACK_GRAPH). + * finalize.c (GC_notify_or_invoke_finalizers): Call + GC_check_finalizer_nested() and skip GC_invoke_finalizers() call + if appropriate. + * include/private/pthread_support.h (GC_Thread_Rep): Add unsigned + finalizer_nested and finalizer_skipped fields (for internal use + by the multi-threaded GC_check_finalizer_nested()). + * win32_threads.c (GC_Thread_Rep): Ditto. + * pthread_support.c (GC_reset_finalizer_nested, + GC_check_finalizer_nested): New function definitions (the + multi-threaded variants of that in finalize.c). + * win32_threads.c (GC_reset_finalizer_nested, + GC_check_finalizer_nested): Ditto. + +2009-09-10 Ivan Maidanski + (diff103_cvs - resembling diff78, diff88_cvs, diff99_cvs, + diff100_cvs, diff101_cvs, diff102_cvs) + + * alloc.c (GC_stopped_mark): Remove GC_log_printf("") (not needed + anymore and GCC produces a warning for it). + * alloc.c (GC_stopped_mark): Adjust printf argument type + specifier. + * backgraph.c: Include dbg_mlc.h before ifdef MAKE_BACK_GRAPH (for + the case when the configuration information comes from aconfig + file). + * checksums.c: Ditto (for gc_priv.h and CHECKSUMS, respectively). + * include/gc_allocator.h (GC_ATTR_UNUSED): Use "__unused__" + keyword instead of "unused". + * include/gc_allocator.h: Fix typos in comments. + * thread_local_alloc.c: Ditto. + * include/javaxfc.h (GC_finalize_all): Update comment. + * include/private/gc_priv.h (GC_API_PRIV): New macro (defined as + GC_API and serves only as a marker for the private but exported + symbols used by test.c only). + * include/private/gc_priv.h (GC_abort, GC_arrays, GC_is_marked, + GC_printf, GC_err_printf, GC_log_printf): Replace GC_API decl with + GC_API_PRIV one. + * include/private/gc_priv.h (GC_fo_entries): Don't export it + outside a DLL. + * include/private/gc_priv.h (GC_ATTR_FORMAT_PRINTF): New macro + designated to check the arguments correctness of printf-like + functions (currently works only for GCC v3+). + * include/private/gc_priv.h (GC_printf, GC_err_printf, + GC_log_printf): Use GC_ATTR_FORMAT_PRINTF attribute. + +2009-09-03 Hans Boehm (really Loren J. Rittle) + + * dyn_load.c (HAVE_DL_ITERATE_PHDR): Break definition from use. + Define for FreeBSD 7.0+. + +2009-09-02 Hans Boehm (with help from Victor Ivrii and + others) + + * mach_dep.c: Don't include ucontext.h with NO_GETCONTEXT. + +2009-08-19 Hans Boehm + + * include/gc_gcj.h (GC_init_gcj_malloc): Improve descriptive + comment. + +2009-08-11 Hans Boehm + (Replacement for Ivan Maidanski's diff99_cvs. Hopefully fixes + the same bugs, and then some.) + + * allchblk.c (GC_merge_unmapped): Don't assume that adjacent + free blocks have different mapping status. Correctly handle gap + between blocks. + (GC_split_block): Remove dead code setting hb_flags. Add comment. + (GC_allochblk): Split blocks also in generational-only mode. + * os_dep.c (GC_unmap_gap): Don't really use munmap. + +2009-08-08 Hans Boehm (Really Ivan Maidanski) + (Mistakenly omitted from last check-in) + + * include/private/gc_priv.h (GC_unmapped_bytes): Define as 0 for + not USE_MUNMAP case. + +2009-08-07 Hans Boehm (Really Ivan Maidanski) + diff111 (supersedes diff101_cvs which, in turn, resembles diff52, + diff75, diff83 partly) + + * Makefile.direct (MARK_BIT_PER_OBJ, PRINT_BLACK_LIST, + USE_PROC_FOR_LIBRARIES): Fix typo in the comments. + * Makefile.direct (USE_MMAP, USE_MUNMAP, THREAD_LOCAL_ALLOC, + PARALLEL_MARK, STATIC): Update the comments. + * include/private/gcconfig.h (GC_PREFER_MPROTECT_VDB): New macro + recognized (only if MPROTECT_VDB). + * Makefile.direct (DONT_USE_USER32_DLL, GC_PREFER_MPROTECT_VDB): + Add the comments for. + * os_dep.c (detect_GetWriteWatch): Recognize "GC_USE_GETWRITEWATCH" + environment variable (only if MPROTECT_VDB, if the variable is + unset when GC_PREFER_MPROTECT_VDB macro controls the strategy). + * doc/README.environment (GC_USE_GETWRITEWATCH): New variable. + * include/private/gcconfig.h (MPROTECT_VDB): Add FIXME for + USE_MUNMAP and PARALLEL_MARK cases (to relax the conditions in + the future). + * misc.c (GC_get_heap_size, GC_get_free_bytes): Ignore the memory + space returned to OS (GC_unmapped_bytes). + * include/gc.h (GC_get_heap_size, GC_get_free_bytes): Update the + comments. + * misc.c (GC_get_unmapped_bytes): New API function. + * include/gc.h (GC_get_unmapped_bytes): New API prototype. + * os_dep.c (GC_dirty_init): Move "ifdef GWW_VDB" block out of + "ifdef MSWIN32" one (for Cygwin). + +2009-08-01 Hans Boehm (Really Ivan Maidanski) + diff100_cvs (diff51 and diff55, partly) + + * pthread_support.c (GC_allow_register_threads): New API function. + * win32_threads.c (GC_allow_register_threads): Ditto. + * include/gc.h (GC_allow_register_threads): New API prototype. + * include/gc.h (GC_register_my_thread, GC_unregister_my_thread): + Update the comments. + * pthread_support.c (GC_register_my_thread): Check the collector + is in the multi-threaded mode. + * win32_threads.c (GC_register_my_thread): Ditto. + +2009-07-10 Hans Boehm + + * finalize.c (GC_finalize_all): Always call GC_invoke_finalizers + instead, following Ivan's original patch. + +2009-06-20 Hans Boehm + + * allchblk.c (GC_allochblk_nth): Add assertion. + * checksums.c: Add GC_record_fault, GC_was_faulted, + CC_n_faulted_dirty_errors. + (GC_check_dirty): Remove register declarations, print + dirty bit errors on faulted pages. + * os_dep.c (GC_write_fault_handler): Call GC_record_fault(). + * os_dep.c (GC_remove_protection): Compute index correctly. + +2009-06-12 Hans Boehm + + * include/gc_version.h, configure.ac, doc/README: + Change to version 7.2alpha3. + * configure: Regenerate. + +[7.2alpha2] + +2009-06-12 Hans Boehm + + * include/gc_version.h, configure.ac, doc/README: + Change to version 7.2alpha2. + * configure: Regenerate. + +2009-06-12 Hans Boehm (Really mostly Ivan Maidanski) + diff98_cvs(resembling diff3, diff27, diff59, diff61, diff66, + diff73 partly) + + * dbg_mlc.c (GC_print_smashed_obj): Convert a group of printf() + calls into a single one (for output atomicity). + * typd_mlc.c (GC_calloc_explicitly_typed): Don't declare and use + GC_finalization_failures variable; check the result of + GC_general_register_disappearing_link() (for lack of memory) + instead. + * finalize.c (GC_finalization_failures): Remove unused global + variable. + * finalize.c (GC_general_register_disappearing_link, + GC_general_register_disappearing_link): Don't update the value of + GC_finalization_failures (since unused). + * include/private/gc_pmark.h (PUSH_ONE_CHECKED_STACK, + GC_PUSH_ONE_STACK, GC_PUSH_ONE_HEAP): The first parameter is of + word type now (as FIXUP_POINTER requires numeric argument). + * finalize.c (GC_ignore_self_finalize_mark_proc): GC_PUSH_ONE_HEAP + requires the first parameter of word type. + * mark.c (PUSH_GRANULE): Ditto. + * mark.c (GC_push_one, GC_push_all_eager): Ditto (for + GC_PUSH_ONE_STACK). + * finalize.c (GC_finalize_all): Call GC_invoke_finalizers() or + GC_finalizer_notifier directly, instead + of GC_INVOKE_FINALIZERS() to prevent infinite looping. + * include/javaxfc.h: Clarify GC_finalize_all comment. + * gcj_mlc.c: Include gc_pmark.h before "ifdef GC_GCJ_SUPPORT" (not + after) for configuration information. + * gcj_mlc.c (GC_gcj_malloc_ignore_off_page): Add comment. + * gcj_mlc.c (GC_gcj_malloc_ignore_off_page): Check "op" local + variable for NULL before dereferencing it, return GC_oom_fn() in + this case. + * typd_mlc.c (GC_malloc_explicitly_typed, + GC_malloc_explicitly_typed_ignore_off_page): Transform the code to + suppress compiler warning (for uninitialized "lg" variable). + +2009-06-12 Hans Boehm + + * win32_threads.c (GC_unregister_my_thread): add false assertion + in unreachable code. + +2009-06-12 Hans Boehm (Really Ivan Maidanski) + diff97_cvs (resembling diff43, diff51, diff67, diff76, diff83 partly) + + * pthread_support.c (GC_inner_start_routine): Don't release the + GC lock between GC_register_my_thread_inner() and + GC_init_thread_local() calls (post the "registered" even after + calling GC_init_thread_local()). + * win32_threads.c (GC_register_my_thread, GC_unregister_my_thread): + Use GC_lookup_thread_inner() instead of GC_lookup_thread() and + acquire the GC lock only once. + * win32_threads.c (GC_thr_init): Call GC_register_my_thread_inner() + directly instead of GC_register_my_thread() since I_HOLD_LOCK + and our (main) thread is not registered yet (add assertion for it). + * win32_threads.c (GC_init_parallel): Call GC_lookup_thread_inner() + directly instead of GC_lookup_thread() (since I_HOLD_LOCK). + * win32_threads.c (GC_lookup_thread): Remove unused function. + * win32_threads.c: Remove "#error GC_DLL untested with Cygwin". + * win32_threads.c (GC_win32_dll_threads): Define as FALSE macro + also if THREAD_LOCAL_ALLOC or GC_PTHREADS. + * win32_threads.c (GC_use_DllMain): Call ABORT also if GC_PTHREADS + (for Cygwin). + * win32_threads.c (GC_push_stack_for): Add parentheses around "&&" + (inside GC_ASSERT) to prevent compiler warning. + * win32_threads.c (GC_push_all_stacks): Remove FIXME for + PARALLEL_MARK. + * win32_threads.c (MAX_MARKERS, GC_markers): Move the definitions + to a place before GC_get_next_stack(). + * win32_threads.c (marker_sp, marker_bsp): New static arrays (same + as in pthread_support.c). + * win32_threads.c (marker_last_stack_min): New static arrays (the + same semantics as for last_stack_min of GC_Thread_Rep). + * win32_threads.c (GC_get_next_stack): Handle marker threads. + * win32_threads.c (GC_mark_thread): Save the current stack pointer + to marker_[b]sp. + * win32_threads.c (start_mark_threads): Initialize + marker_last_stack_min elements (to "unset" value). + +2009-06-12 Hans Boehm (Really Ivan Maidanski) + (diff96_cvs, partly from diff45 and diff75) + + * misc.c (GC_set_oom_fn, GC_set_all_interior_pointers, + GC_set_finalize_on_demand, GC_set_java_finalization, + GC_set_finalizer_notifier, GC_set_dont_expand, GC_set_full_freq, + GC_set_no_dls, GC_set_free_space_divisor, GC_set_max_retries, + GC_set_dont_precollect, GC_set_time_limit, GC_set_warn_proc): + Change return type to void (these API functions no longer return + the old value). + * include/gc.h: Ditto (for prototypes). + * tests/test.c (main, WinMain, test): Remove explicit cast to void + for GC_set_warn_proc(). + * misc.c (GC_get_oom_fn, GC_get_all_interior_pointers, + GC_get_finalize_on_demand, GC_get_java_finalization, + GC_get_finalizer_notifier, GC_get_dont_expand, GC_get_full_freq, + GC_get_no_dls, GC_get_free_space_divisor, GC_get_max_retries, + GC_get_dont_precollect, GC_get_time_limit, GC_get_warn_proc): New + API functions (to get the current value of the corresponding R/W + public variables). + * include/gc.h: Ditto (for prototypes). + * include/gc.h (GC_set_warn_proc, GC_set_free_space_divisor): + Update the comment. + * misc.c (GC_ignore_warn_proc): New API call-back function. + * include/gc.h (GC_ignore_warn_proc): Ditto (for the prototype). + * misc.c (GC_set_find_leak, GC_get_find_leak, GC_set_non_gc_bytes, + GC_get_non_gc_bytes): New API setter and getter functions (for the + public GC_find_leak and GC_non_gc_bytes variables, respectively). + * include/gc.h: Ditto (for prototypes). + * include/gc.h (GC_memalign): Add proto to GC API. + * mallocx.c (GC_memalign): Use GC_API, GC_CALL for the definition. + * tests/test.c (run_one_test): Test GC_memalign() on Win32 too, + remove GC_memalign() proto. + * misc.c (GC_write): Use multi-byte (A) variants of Win32 + GetModuleFileName() and CreateFile(). + * tests/test.c (main): Replace K&R-style function definition with the + ANSI C one. + +2009-06-12 Hans Boehm (Really Ivan Maidanski and + George Talbot) + (diff95_cvs) + + * include/private/gcconfig.h (PLATFORM_ANDROID): New macro + recognized (for Linux on ARM32 without glibc). + * include/private/gcconfig.h (STRTOULL): Define for all targets + (define as "strtoul" for most targets except for LLP64/Win64). + * misc.c (GC_init_inner): Use STRTOULL instead of atoi/atol() + (cast the result to word type) to decode values of "GC_TRACE", + "GC_INITIAL_HEAP_SIZE", "GC_MAXIMUM_HEAP_SIZE" environment + variables. + +2009-06-12 Hans Boehm (Really mostly George Talbot) + + * include/gc_allocator.h: Add gc_allocator_ignore_off_page. + * tests/test_cpp.cc: Add call to gc_allocator_ignore_off_page. + +2009-06-11 Hans Boehm + + * win32_threads.c (GC_release_mark_lock): Correct misspelling of + AO_load in assertion. + +2009-06-11 Hans Boehm (Really mostly Ivan Maidanski) + (diff93_cvs: resembling diff27, diff30, diff43, diff44, diff66, + diff76, diff79, diff83 partly) + + * win32_threads.c (MAX_THREADS): Define as 1 if GC_win32_dll_threads + is defined as FALSE (otherwise the size of dll_thread_table is near + 200 KiB for 32-bit). + * win32_threads.c (GC_use_DllMain): Optimize for THREAD_LOCAL_ALLOC. + * win32_threads.c (GC_Thread_Rep): Add backing_store_end and + backing_store_ptr fields for IA64 support. + * win32_threads.c (GC_register_my_thread_inner): Set + backing_store_end field to reg_base value for IA64 (same as in + pthread_support.c). + * win32_threads.c (SET_PTHREAD_MAP_CACHE): Put parentheses in the + "right" places, remove ';'. + * win32_threads.c (GC_fault_handler_lock): Declare only + if MPROTECT_VDB (and not WinCE). + * win32_threads.c (GC_suspend): Acquire and release + GC_fault_handler_lock only if MPROTECT_VDB (and not WinCE). + * win32_threads.c (GC_suspend): Define as STATIC. + * win32_threads.c (GC_push_stack_for): Fix WARN() format specifier + (should be word-compliant, "%p" is used w/o "0x"), don't cast sp. + * win32_threads.c (GC_push_all_stacks): Convert a group of printf() + calls into a single one (for output atomicity). + * win32_threads.c (GC_get_next_stack): Unprotect thread descriptor + before altering its last_stack_min ("thread" variable is added). + * win32_threads.c (GC_get_next_stack): Remove unnecessary checks for + "s" is non-NULL. + * win32_threads.c (GC_get_next_stack): Don't call GC_may_be_in_stack + if WinCE. + * win32_threads.c (GC_get_next_stack): Pass current_min value to + GC_get_stack_min as-is (without -1). + * win32_threads.c (GC_wait_marker): Remove FIXME and use "release" + version of AO_fetch_and_sub1(). + * win32_threads.c (GC_win32_start_inner, GC_win32_start): convert int + to pointer (and vice versa) thru word type to suppress warnings. + * win32_threads.c (GC_mark_mutex_waitcnt): Fix comment, always + access atomically. + * misc.c: Change GC_THREADS tests back to THREADS. + + +2009-06-11 Hans Boehm (Really Ivan Maidanski) + (diff92_cvs: resembling diff20, diff27, diff34, diff38, diff43, diff45, + diff46, diff56, diff60, diff62, diff74, diff75, diff81 partly) + + * allchblk.c (GC_print_hblkfreelist, GC_dump_regions): Convert + a group of printf() calls into a single one (for output atomicity). + * include/gc.h (GC_set_all_interior_pointers, GC_set_full_freq, + GC_set_time_limit): New prototypes. + * misc.c (GC_set_all_interior_pointers, GC_set_full_freq, + GC_set_time_limit): New public setter/getter functions. + * include/gc.h: Fix (and remove outdated) comments for thread-local + allocation. + * include/gc.h: Fix typos in comments. + * misc.c (GC_init_inner, GC_printf): Ditto. + * include/gc.h (GC_unregister_disappearing_link): Refine comment. + * include/gc.h (GC_stack_base): Recognize _M_IA64 macro. + * misc.c (GC_stack_last_cleared, GC_min_sp, GC_high_water, + GC_bytes_allocd_at_reset, DEGRADE_RATE): Define only if THREADS. + * misc.c (GC_stack_last_cleared, GC_min_sp, GC_high_water, + GC_bytes_allocd_at_reset): Define as STATIC. + * misc.c (GC_get_heap_size, GC_get_free_bytes, + GC_get_bytes_since_gc, GC_get_total_bytes): Acquire the GC lock to + avoid data races. + * misc.c (GC_write_cs): Define only if THREADS (Win32/WinCE only). + * misc.c (GC_init_inner): Initialize GC_write_cs only if THREADS. + * misc.c (GC_init_inner): Use GC_INITIAL_HEAP_SIZE (if available) to + set the default initial value of initial_heap_sz. + * misc.c (GC_deinit): Destroy GC_write_cs only if THREADS. + * misc.c (GC_init_inner): Fix WARN() format specifier (should be + word-compliant, "%p" is used w/o "0x"). + * misc.c (GC_init_inner): Don't recognize "GC_PAUSE_TIME_TARGET" + environment variable if SMALL_CONFIG. + * misc.c (GC_init_inner): Recognize "GC_FULL_FREQUENCY" environment + variable to set initial GC_full_freq value (if not SMALL_CONFIG). + * doc/README.environment (GC_FULL_FREQUENCY): Add information. + * doc/README.environment (GC_MARKERS): Refine information. + * misc.c (GC_init_inner): Change GC_ASSERT to GC_STATIC_ASSERT where + possible. + * misc.c (IF_NEED_TO_LOCK): New macro (instead of GC_need_to_lock). + * misc.c (GC_write): Use IF_NEED_TO_LOCK for handling GC_write_cs. + * misc.c (GC_abort): Don't define if SMALL_CONFIG. + * misc.c (GC_abort): Directly use WRITE() instead of GC_err_printf() + (to prevent possible infinite recursion). + +2009-06-09 Hans Boehm (Really Ivan Maidanski) + diff90_cvs (resembling diff28, diff30, diff32, diff34, diff47, + diff49, diff60, diff62, diff66, diff67, diff68, diff72 partly) + + * finalize.c (finalization_mark_proc): Replace K&R-style declaration + with ANSI C one. + * finalize.c (GC_grow_table, GC_register_finalizer_inner, + GC_enqueue_all_finalizers): Remove outdated comments about disabling + signals. + * finalize.c (GC_general_register_disappearing_link): Fix assertion + to catch NULL "obj" value. + * finalize.c (GC_unregister_disappearing_link): Check "link" + alignment before gaining the lock. + * finalize.c (GC_finalize): Refine comment. + * finalize.c (GC_finalize): Fix WARN() format specifier (should be + word-compliant, "%p" is used w/o "0x"). + * finalize.c (GC_invoke_finalizers): Initialize "bytes_freed_before" + variable (to 0) to suppress compiler warning. + * include/gc_gcj.h (MARK_DESCR_OFFSET): Move to private/gc_pmark.h. + * include/gc_gcj.h: add "extern C" header and tail. + * include/private/gc_pmark.h: Remove GC_do_parallel_mark(), + GC_help_wanted, GC_helper_count, GC_active_count declarations (move + the comments to the place where these symbols are defined in mark.c). + * mark.c: Add STATIC GC_do_parallel_mark() declaration (for use by + GC_mark_some_inner, if PARALLEL_MARK only). + * mark.c (GC_mark_some_inner, GC_help_wanted, GC_helper_count, + GC_active_count, GC_do_parallel_mark): Define as STATIC. + * pthread_support.c (GC_mark_thread): Ditto. + * typd_mlc.c (GC_explicit_typing_initialized, GC_explicit_kind, + GC_array_kind, GC_ext_descriptors, GC_ed_size, GC_avail_descr, + GC_typed_mark_proc_index, GC_array_mark_proc_index, GC_eobjfreelist, + GC_arobjfreelist): Ditto. + * include/private/gc_pmark.h (PUSH_CONTENTS_HDR): Change GC_ASSERT + for HBLKSIZE to GC_STATIC_ASSERT. + * mark.c (GC_noop): Define for Borland C the same as for Watcom. + * mark.c (GC_noop, GC_mark_and_push): Add ARGSUSED tag. + * pthread_support.c (GC_do_blocking_inner): Ditto. + * mark.c (GC_mark_from): Initialize "limit" (to 0) in the default + switch branch to suppress compiler warning. + * mark.c (GC_return_mark_stack): Append new-line to printf message. + * mark.c: Remove unused GC_true_func(), GC_PUSH_ALL(). + * pthread_support.c (GC_mark_thread): Add dummy "return 0" to + suppress compiler warning. + * pthread_support.c (start_mark_threads): Move the code limiting + "GC_markers" value (and printing a warning) to GC_thr_init(). + * pthread_support.c (GC_thr_init): Silently limit "GC_markers" value + if based on the number of CPUs. + * pthread_support.c (GC_thr_init): Treat incorrect "GC_markers" + values as one. + * pthread_support.c (GC_register_my_thread_inner): Add a check for + "stack_end" is non-NULL (the same as in win32_threads.c). + * pthread_support.c (pthread_create): Call GC_oom_fn before giving up + with ENOMEM. + * thread_local_alloc.c (return_single_freelist): Convert "for" loop + to "while" one to suppress "possible extraneous ';'" warning. + +2009-06-08 Hans Boehm (Really Ivan Maidanski + and Zoltan Varga) + + * darwin_stop_world.c (GC_push_all_stacks): Recognize ARM32. + * include/private/gc_priv.h (GC_THREAD_STATE_T): Define for ARM32 + (Darwin only). + * include/private/gcconfig.h: Add machine-specific part for DARWIN. + * include/private/gcconfig.h (ARM32): Define config parameters for + DARWIN (iPhone). + +2009-06-08 Hans Boehm (Really Ivan Maidanski) + (diff91_cvs: resembling diff3, diff27, diff33, diff45, diff47, diff49, + diff60, diff67, diff68 partly) + + * alloc.c (GC_FULL_FREQ, GC_DONT_EXPAND, GC_FREE_SPACE_DIVISOR, + GC_TIME_LIMIT): New macros (used to control the default initial + values of GC_full_freq variable, GC_dont_expand, + GC_free_space_divisor, GC_time_limit respectively). + * include/private/gc_priv.h (TIME_LIMIT): Remove macro (replaced + with GC_TIME_LIMIT in alloc.c). + * alloc.c (GC_need_full_gc, GC_stopped_mark, GC_finish_collection): + Define as STATIC. + * mark_rts.c (GC_push_current_stack, GC_push_gc_structures): Ditto. + * include/private/gc_priv.h (GC_stopped_mark, GC_finish_collection): + Move the prototypes to alloc.c, make STATIC. + * include/private/gc_priv.h (GC_push_current_stack, + GC_push_gc_structures, GC_push_regs_and_stack): Remove prototypes + (move the comments to the places where these functions are defined). + * mach_dep.c (GC_push_regs_and_stack): Move to mark_rts.c and define + as STATIC. + * alloc.c (GC_timeout_stop_func, GC_stopped_mark, + GC_print_heap_sects): Convert a group of printf() calls into + a single one (for output atomicity). + * mark_rts.c (GC_print_static_roots): Ditto. + * alloc.c (GC_stopped_mark): Output blank line (when logging) for + convenience to delimit collections. + * alloc.c (GC_clear_a_few_frames): Rename NWORDS to CLEAR_NWORDS; + make "frames" local variable volatile (to prevent optimization). + * alloc.c (GC_try_to_collect_inner, GC_stopped_mark, + GC_finish_collection, GC_allocobj): Remove outdated comments about + disabling signals. + * include/private/gc_priv.h (GC_register_displacement_inner, + GC_gcollect_inner): Ditto. + * alloc.c (GC_try_to_collect_inner, GC_stopped_mark, + GC_finish_collection): Initialize "start_time" local variable (to 0) + to suppress compiler warning. + * mark_rts.c (GC_add_roots_inner): Ditto (for "old" variable). + * alloc.c (GC_RATE, MAX_PRIOR_ATTEMPTS): Guard with "ifndef". + * include/private/gc_priv.h (clock, GC_stop_world, GC_start_world, + GC_acquire_mark_lock, GC_release_mark_lock, GC_notify_all_builder, + GC_wait_for_reclaim, GC_notify_all_marker, GC_wait_marker): Replace + K&R-style function prototypes with ANSI C one. + * include/private/gc_priv.h (ABORT): Define as DebugBreak() for + Win32/WinCE if SMALL_CONFIG (the same as in GC_abort()). + * include/private/gc_priv.h (ROUNDED_UP_WORDS, abs): Remove unused + macros. + * include/private/gc_priv.h (GC_noop): Declare for Borland C the + same as for Watcom. + * mark_rts.c (GC_push_conditional_with_exclusions): Add ARGSUSED tag. + +2009-06-04 Hans Boehm (Really Ivan Maidanski) + (diff89_cvs, resembling diff3, diff27, diff34, diff38, diff47, diff49, + diff59, diff60, diff66, diff67, diff68, diff69a, diff70, diff81 + partly) + + * dbg_mlc.c (GC_store_debug_info, GC_store_debug_info_inner): Remove + outdated comment about disabling signals. + * mallocx.c (GC_malloc_uncollectable, + GC_malloc_atomic_uncollectable): Ditto. + * os_dep.c: Ditto. + * dbg_mlc.c (GC_debug_change_stubborn, GC_debug_end_stubborn_change): + Add ARGSUSED tag. + * pthread_stop_world.c (GC_suspend_handler, + GC_suspend_handler_inner): Ditto. + * dbg_mlc.c (GC_debug_free, GC_debug_realloc): Fix printf message. + * dbg_mlc.c (GC_debug_realloc): Set "result" to NULL in the default + switch branch to suppress compiler warning. + * dyn_load.c (GC_init_dyld): Use ABORT() instead of GC_abort(). + * include/private/darwin_semaphore.h (sem_init): Ditto. + * include/javaxfc.h: Replace "GC_H" with "_GC_H". + * include/private/dbg_mlc.h (GC_has_other_debug_info, + GC_store_debug_info): Replace K&R-style function prototypes with ANSI + C one. + * include/private/gcconfig.h (GC_FreeBSDGetDataStart, real_malloc, + GC_win32_get_mem, GC_wince_get_mem, GC_unix_get_mem): Ditto. + * include/private/pthread_support.h (GC_stop_init): Ditto. + * include/private/gcconfig.h: Refine comment about setting + GC_stackbottom. + * include/private/gcconfig.h (FIXUP_POINTER): Put parentheses in the + "right" places. + * include/private/pthread_support.h (GC_Thread_Rep): Refine comment + for "stack_end" field. + * mallocx.c (GC_malloc_uncollectable, + GC_malloc_atomic_uncollectable): Remove cast to undefined "hbklk". + * os_dep.c (GC_USE_MEM_TOP_DOWN): New macro (for setting + GC_mem_top_down to MEM_TOP_DOWN for debug purposes). + * os_dep.c (GC_gww_read_dirty, catch_exception_raise): Fix WARN() + format specifier (should be word-compliant, "%p" is used w/o "0x"). + * pthread_stop_world.c (GC_suspend_handler_inner): Ditto. + * os_dep.c (GC_dirty_init): Append new-line to printf messages. + * os_dep.c (GC_mprotect_thread): Fix GC_err_printf message. + * os_dep.c (GC_save_callers): Change GC_ASSERT to GC_STATIC_ASSERT. + * pthread_stop_world.c (GC_retry_signals, GC_suspend_ack_sem): Define + as STATIC. + * pthread_stop_world.c (GC_push_all_stacks): Add assertion for that + "thread_blocked" is not set for the current thread. + * real_malloc.c: Add "extern GC_quiet" to suppress compiler warning. + * reclaim.c (GC_reclaim_all): Initialize "start_time" (to 0) to + suppress compiler warning. + +2009-06-02 Hans Boehm (Really Ivan Maidanski) + (adding last bit of diff86_cvs) + + * tests/test.c (check_heap_stats): Avoid unbalanced brackets in ifdef. + +2009-05-27 Hans Boehm (Really Ivan Maidanski) + (diff26) + + * win32_threads.c: restructure parallel marking mutex initialization. + * win32_threads.c, alloc.c, darwin_stop_world.c, mallocx.c, mark.c, + pthread_stop_world.c, pthread_support.c: Add runtime conditions + on GC_parallel were appropriate. + * pthread_support.c: Condition marker_bsp on ia64. + (GC_segment_is_thread_stack): Fix loop upper bound. + * reclaim.c: Limit some assertions to PARALLEL_MARK. + * pthread_support.c: Don't acquire mark lock for thread-local + allocation. + * include/private/gc_priv.h: Don't define parallel mark sync + support just for THREAD_LOCAL_ALLOC. + +2009-05-27 Hans Boehm (Really Ivan Maidanski) + (diff39) + + * include/private/gcconfig.h: refine MINGW32 test. + * mark.c: Add win64/gcc tests. + +2009-05-27 Hans Boehm (Really Ivan Maidanski) + (diff86_cvs, resembling diff28, diff32, diff33, diff38, diff68 partly) + + * test.c (fork_a_thread, reverse_test, alloc8bytes, tree_test, + typed_test, run_one_test, check_heap_stats, main, test): Replace + all K&R-style function definitions with ANSI C ones. + * trace_test.c (main): Ditto. + * test.c (GC_COND_INIT): Define as GC_INIT() also in case of + THREAD_LOCAL_ALLOC. + * test.c (reverse_test): Call fork_a_thread() only if GC_PTHREADS + or GC_WIN32_THREADS; remove fork_a_thread() macros definition. + * test.c (reverse_test): Use "volatile" when clearing "b" and "c" + local variables (to suppress "assigned value is never used" + compiler warning). + * test.c (tree_test): Use public GC_noop1() instead of private + GC_noop(). + * test.c (typed_test): Ditto. + * test.c (check_heap_stats): Define and assign value to + "late_finalize_count" local variable only if its value is used + (if FINALIZE_ON_DEMAND defined). + * test.c (main): Remove DJGPP-specific initialization of + GC_stackbottom (not needed anymore, handled in gcconfig.h). + * trace_test.c: Guard #define GC_DEBUG with #ifndef. + * trace_test.c: Include "gc_backptr.h". + * trace_test.c (main): Call GC_INIT(). + * trace_test.c (main): Add "return 0" statement. + +2009-05-25 Hans Boehm (Really Petter Urkedal) + + * dyn_load.c (GC_register_dynlib_callback): Use new index j + instead of i in the inner loop. + +2009-05-24 Hans Boehm (Really Ivan Maidanski) + (diff85) + + * tests/test.c: Increment n_tests with fetch_and_add when possible, + avoiding need to export lock. + +2009-05-22 Hans Boehm (Really Ivan Maidanski) + (diff63,diff65) + + * include/gc_pthread_redirects.h: + - dlfcn.h is included for dlopen() proto before undefining + "dlopen" (so, it's possible now to include dlfcn.h after + gc.h from user code); + - GC_dlopen() proto is added (except for Darwin as + it's missing there); + - "dlopen" is explicitly undefined (before its redefinition). + * include/gc.h: + - "process.h" is included besides "windows.h" + (for _beginthreadex/_endthreadex); win32 only. + - GC_NO_THREAD_DECLS is moved to the right place + (before closing "extern C"). + * pthread_support.c: Fix out of memory handling for Thread_Reps. + * win32_threads.c: Don't include process.h on winCE, + improve out of memory handling for thread structures, don't + define GC_beginthreadex and GC_endthreadex for winCE. + +2009-05-22 Hans Boehm (Really Ivan Maidanski + (diff71) + + * tests/test.c: Change gcj vtable decriptor type from size_t to + GC_word. + +2009-05-22 Hans Boehm + + * gcj_mlc.c: Add comment. + * tests/test.c: Change NTEST to NTHREADS. Fork 5 threads by default. + Run reverse_test a second time in each thread.Add comments. + Don't rely on AO_fetch_and_add. + +2009-05-22 Hans Boehm (Largely from Ludovic Cortes) + + * dyn_load.c (GC_register_dynlib_callback, + GC_register_dynamic_libraries_dl_iterate_phdr): Add support + for GNU_PT_RELRO relocations. + +2009-05-22 Hans Boehm (Really Ivan Maidanski) + (diff61) + + * Makefile, Makefile.direct: GC_SOLARIS_PTHREADS was replaced + by GC_SOLARIS_THREADS. + * include/gc.h: Improve finalizer documentation. + * mips_sgi_mach_dep.s: Replace _MIPS_SIM_ABI32 with _ABIO32. + * pthread_stop_world.c, Makefile.dj: Fix typos. + +2009-05-21 Hans Boehm + + * win32_threads.c (GC_new_thread): Make first_thread + visible to the whole file. + (UNPROTECT): New macro. + (GC_push_stack_for, GC_suspend, GC_start_world): unprotect + thread structures before writing. + (GC_suspend): Acquire GC_fault_handler_lock before suspending + thread. + * os_dep.c: export GC_fault_handler_lock. + (GC_remove_protection): Check if already unprotected. + +2009-05-20 Hans Boehm (really Ivan Maidanski) + + * doc/README.win32: Add OpenWatcom warning. + * include/private/gcconfig.h: Really check it in. + +2009-05-19 Hans Boehm (Mostly Ivan Maidanski, Dave Korn) + + * os_dep.c (GC_get_stack_base, windows): Replace with Dave Korn's + code from gcc version. + * os_dep.c: make gc compilable (optionally) for Cygwin with + GetWriteWatch-based virtual dirty bit implementation ("os_dep.c" file). + * os_dep.c: Make non-win32 GC_write_fault_handler STATIC. + * mark.c (GC_noop): fix declaration definition mismatch for DMC. + * include/private/gcconfig.h: Enable MPROTECT_VDB and GWW_VDB for + Watcom (Win32 only). It works. + +2009-05-07 Hans Boehm (and Mark Sibly) + + * mach_dep.c: Don't use __builtin_unwind_init for register + state on PowerPC/Darwin. + +2009-04-24 Hans Boehm + + * doc/gcdescr.html: Improve description of object freelist + structure. + * include/private/gc_priv.h: Fix comment for _size_map. + +2009-03-16 Hans Boehm + + * os_dep.c (GC_linux_stack_base): Relax sanity test. + +2009-03-11 Hans Boehm (Really Ivan Maidanski) + + * include/private/gc_pmark.h (PUSH_CONTENTS_HDR for + MARK_BIT_PER_OBJ): Add missing backslash before eoln. + +2009-02-28 Hans Boehm + + * misc.c (GC_set_warn_proc): Implicitly intialize GC on + non-Cygwin win32. + +2009-02-28 Hans Boehm (Really Petr Krajca) + + * configure.ac: Enable thread-local allocation for sparc-linux. + * configure: Regenerate. + +2009-02-28 Hans Boehm (Really Ivan Maidansky) + + * alloc.c (GC_try_to_collect): Remove duplicate initialization + check. + * malloc.c (GC_generic_malloc): Remove lw to eliminate single- + threaded warnings. + * mallocx.c (GC_generic_malloc_ignore_off_page): Ditto. + +2009-02-28 Hans Boehm (Mostly Ivan Maidansky) + + * allchblk.c, backgraph.c, dbg_mlc.c, dyn_load.c, + finalize.c, include/private/gc_pmark.h, malloc.c, mark.c, + os_dep.c, pthread_stop_world.c, pthread_support.c, reclaim.c, + thread_local_alloc.c. + * misc.c: Refine comment. + +2009-02-28 Hans Boehm + + * os_dep.c: Define GC_GWW_BUF_LEN more intelligently. Add FIXME + comment. + +2009-02-28 Hans Boehm (With input from Ivan Maidansky) + + * win32_threads.c (GC_push_stack_for): Yet another attempt + at the stack_min finding logic. Try to clean up the existing code + while minimizing VirtualQuery calls. + (GC_win32_start_inner): Register thread before GC_printf. + Produce more output with DEBUG_THREADS. + *include/gc.h: Update obsolete comments. + +2009-02-24 Hans Boehm (Really Ivan Maidansky) + + * tests/test.c: + (gcj_class_struct2): Use cast instead of l suffix. + Cast GetLastError to int in various places. + Avoid unused result warning from incr/decr macros. + Add cast for fake_gcj_mark_proc. + Cast GC_gc_no to unsigned in printf. + +2009-02-24 Hans Boehm (Really Ivan Maidansky) + + * include/gc.h: Fix two typos in comments. + +2009-02-24 Hans Boehm (Really Ivan Maidansky) + + * finalize.c: Fix typo in comment. + +2008-12-03 Hans Boehm (Really Ivan Maidansky) + + * blacklst.c (GC_print_source_pointer): Don't call GC_print_heap_obj + with lock. + +2008-12-01 Hans Boehm + + * reclaim.c: (GC_reclaim_block): Scan even nearly full blocks + if we are checking for leaks. + +2008-11-12 Hans Boehm (Really mostly Ivan Maidansky) + + * win32_threads.c: Remove mark lock spinning. + * win32_threads.c, pthread_support.c: Update GC_unlocked_count, + GC_spin_count, and GC_block_count using atomic operations. + * tests/test.c: Declare n_tests as AO_t only if we have threads. + +2008-11-11 Hans Boehm + (Really almost entirely Ivan Maidansky) + + * win32_threads.c: Support PARALLEL_MARK. Make printf arg + types agree with format specifiers. Add missing copyright header. + Add STATIC for GC_threads. + * include/private/gcconfig.h: Add FIXME comment. + * tests/test.c (run_ine_test): Replace LOCK/UNLOCK use with + AO_fetch_and_add1_full. Declare n_tests as AO_t. + (WinMain): Don't call GC_use_DllMain. + with PARALLEL_MARK or THREAD_LOCAL_ALLOC. + +2008-11-10 Hans Boehm (Really Ivan Maidansky) + + * alloc.c (GC_try_to_collect_inner): Don't print redundant + GC_bytes_allocd and GC_gc_no. + (GC_stopped_mark): Print average world stop time. + * include/private/gc_priv.h (MS_TIME_DIFF): Add cast. + +2008-11-10 Hans Boehm (Really mostly Ivan Maidansky) + + * misc.c, doc/README.environment: Add support for + GC_FREE_SPACE_DIVISOR and GC-disable-incremental. + * include/gc.h: Make GC_set_free_space_divisor correspond to + (somewhat unfortunate) reality. + +2008-11-07 Hans Boehm (Really Ivan Maidansky) + + (Mostly improves LLP64 support.) + * backgraph.c, checksums.c, dbg_mlc.c, finalize.c, mark.c, + misc.c, reclaim.c: Changed some int and long type to word or size_t + (and vice versa where appropriate) + * gcj_mlc.c, include/private/dbg_mlc.h, include/private/gcconfig.h, + include/private/thread_local_alloc.h, mark.c, + misc.c, thread_local_alloc.c, win32_threads.c: Added intermediate + casts to word type when casting from int to pointer (or pointer + to int, or data pointer to code pointer) - just to remove the + corresponding compiler warning. + * ptr_chck.c (GC_is_visible): cast int const to word type to + prevent left shift overflow. + * os_dep.c: change the type of GC_mem_top_down global variable + (containing a flag) to DWORD. + * include/gc_config_macros.h: define GC_SOLARIS_THREADS if GC_THREADS + is defined on SunOS x86_64. + * misc.c (GC_init_size_map): Ifdef out GC_ASSERT as a workaround + for VC++ 2008 amd64 (v15.00.21022.08 for x64) compiler bug + (the compiler gets hung if invoked with -Ox -D + ALL_INTERIOR_POINTERS -D GC_ASSERTIONS) + * backgraph.c: cast GC_gc_no value to unsigned short when + assigned/compared to height_gc_no field of back_edges. + * os_dep.c (GC_remove_protection): Add ARGSUSED. + * win32_threads.c (GC_thread_exit_proc): Remove unused local + variable. + * mark.c (GC_check_dirty): Move declaration out of func body. + +2008-11-06 Hans Boehm + + * doc/gcinterface.html: Improve REDIRECT_MALLOC documentation. + * include/gc.h (GC_register_my_thread): Improve comment. + +2008-11-04 Hans Boehm + + * Makefile.direct: Add comment for -DCHECKSUMS. + +2008-10-27 Hans Boehm (Really Ivan Maidansky) + + * thread_local_alloc.c, include/private/thread_local_alloc.h: + Fix typos in comments. + * finalize.c: Declare mark_procs and GC_register_finalizer_inner + STATIC. + * malloc.c (GC_free): Move size calculation below assertion. + +2008-10-27 Hans Boehm + + * win32_threads.c (GC_get_stack_min, GC_may_be_in_stack): + Add one entry VirtualQuery cache, I_HOLD_LOCK assertions. + (GC_push_stack_for, GC_get_next_stack) : Hopefully fix WINCE support. + +2008-10-27 Hans Boehm (Thanks to Klaus Treichel) + + * finalize.c (GC_general_register_disappearing_link): Add + assertion. + * malloc.c (GC_generic_malloc): Round lb to granules, not words. + * mallocx.c (GC_generic_malloc_ignore_off_page): Round lb to + granules, not words. + +2008-10-27 Hans Boehm (Really Rex Dieter and + Petr Krajca) + + * mach_dep.c (NO_GETCONTEXT): Define for sparc linux. + * configure.ac: Define mach_dep for sparc-linux. + * configure: Regenerate. + +2008-10-25 Hans Boehm (Really Ivan Maidansky) + + * mark_rts.c (GC_approx_sp): Use volatile to avoid common + warning. + +2008-10-25 Hans Boehm + + * dyn_load.c (GC_cond_add_roots): Fix GC_get_next_stack argument + order. + +2008-10-24 Hans Boehm (Really Ivan Maidanski) + + * alloc.c, dbg_mlc.c, dyn_load.c, finalize.c, gcj_mlc.c, + include/gc.h, include/gc_config_macros.h, include/gc_cpp.h, + include/gc_gcj.h, include/gc_mark.h, include/gc_typed.h, + include/javaxfc.h, include/private/gc_locks.h, + include/private/gc_priv.h, malloc.c, mallocx.c, mark.c, mark_rts.c, + misc.c, obj_map.c, os_dep.c, pthread_support.c, ptr_chck.c, + stubborn.c, tests/test.c, thread_local_alloc.c, typd_mlc.c + win32_threads.c: Add GC_CALL and GC_CALLBACK macro invocations. + * test.c: Remove some old K&R code. + +2008-10-24 Hans Boehm + (Partially based loosely on patch from Ivan Maidanski) + + * win32_threads.c (GC_may_be_in_stack): New. (GC_Thread_Rep): + Add last_stack_min. (GC_push_stack_for): Use last_stack_min. + (GC_get_next_stack): Add limit argument, use_last_stack_min. + (GC_suspend): make stack_base assignment conditional. + * dyn_load.c (win32 GC_cod_add_roots): Pass limit to + GC_get_next_stack. + * configure_atomic_ops.sh: Remove. + * build_atomic_ops.sh, build_atomic_ops.sh.cygwin, doc/README.win32, + Makefile.direct: Partially support build directories whose path + name contains blanks. + * Makefile.am: Support new files (build_atomic_ops.sh, + build_atomic_ops.sh.cygwin) + * Makefile.in: Regenerate. + +2008-10-21 Hans Boehm (Really Ivan Maidanski) + + * include/private/gc_locks.h, include/private/gc_pmark.h, + include/private/gc_priv.h, include/private/gcconfig.h, + mach_dep.c, mark_rts.c, misc.c, os_dep.c, pthread_stop_world.c, + pthread_support.c, thread_local_alloc.c, typd_mlc.c, win32_threads.c: + Fix comments. + +2008-10-21 Hans Boehm (Really Ivan Maidanski) + + * pthread_support.c: Comment out LOCK_STATS. + * include/gc.h: Fix comments. + +2008-10-20 Hans Boehm (Really Ivan Maidanski) + + * misc.c (GC_init_inner): Enable GC_LOG_FILE on Cygwin. + * include/private/gcconfig.h: Consider USE_MMAP for Cygwin. + * os_dep.c (GC_get_main_stack_base): Use alternate definition + with USE_MMAP. + * include/private/gc_priv.h: Sometimes define SETJMP on Cygwin. + +2008-10-20 Hans Boehm + + * doc/README: Make it clearer when Makefile.direct is assumed. + * cord/cord.am: install include/cord.h. + * Makefile.in: Regenerate. + +2008-09-24 Hans Boehm (Really Ivan Maidanski) + + * win32_threads.c (GC_pthread_join, GC_pthread_start_inner): + Remove unused variables. + * darwin_stop_world.c: Always declare GC_thr_init(). + * dbg_mlc.c (GC_debug_free_inner): Don't touch oh_sz if + SHORT_DBG_HDRS is defined. + * include/private/gc_pmark.h (OR_WORD_EXIT_IF_SET, parallel + mark, USE_MARK_BITS version): Refer to correct parameter name. + +2008-09-24 Hans Boehm (Really Ivan Maidanski) + + * finalize.c (GC_general_register_disappearing_link): Remove + redundant code. + * gcj_mlc.c (GC_init_gcj_malloc): Add cast to signed. + * os_dep.c: (GC_write_fault_handler): Remove remaining + references to deleted variable "code". Remove redundant + FREEBSD definitions. + * include/private/gcconfig.h (GWW_VDB): Define for X86_64 when + defined for X86. (STATIC): Define as "static" with NO_DEBUGGING. + +2008-09-24 Hans Boehm + + * include/private/gc_priv.h: Update MAX_HEAP_SECTS. + +2008-09-10 Hans Boehm + + * dbg_mlc.c (GC_print_smashed_obj): Increase robustness with + smashed string, (GC_debug_free_inner): Mark as free. + * mallocx.c (GC_malloc_many): Always clear new block if + GC_debugging_started. + * reclaim.c: Move GC_debugging_started from + GC_reclaim_small_nonempty_block() to GC_reclaim_generic(), + which is also called directly. + * doc/README: Fix spelling error. Update license summary. + * include/gc.h (GC_PRE_INCR3, GC_POST_INCR3): add (void **) casts. + * tests/test.c: Don't define GC_DEBUG if already defined. + +2008-08-27 Hans Boehm + + * doc/simple_example.html: update --enable-full-debug reference, + Make HTML formatting standards compliant. + * doc/debugging.html, doc/leak.html: Fix HTML formatting bugs. + * doc/gcinterface.html: specify encoding. + +2008-08-27 Hans Boehm (with help from Marco Maggi) + + * doc/simple_example.html: Update thread-local allocation + description. + +2008-08-26 Hans Boehm (with help from Marco Maggi) + + * configure.ac: Check for gc-debug earlier; replace remaining + full-debug tests. + * configure: Regenerate. + * include/gc.h, ptr_chck.c (GC_pre_incr, GC_post_incr): + Use signed offset type. Use ptr_t internally. + * doc/gcinterface.html: Update LOCAL_MALLOC description. + * doc/README.autoconf, doc/leak.html, doc/README.DGUX386: + Fix full-debug reference. + * include/gc.h: Rewrite GC_..._INCR and friends. + * tests/test.c: Minimally test GC_..._INCR and friends. + +2008-08-21 Hans Boehm + + * mark.c: (GC_push_next_marked, GC_push_next_marked_dirty, + GC_push_next_marked_uncollectable): Never invoke GC_push_marked + on free hblk. + * headers.c: Test COUNT_HDR_CACHE_HITS not USE_HDR_CACHE. + (GC_header_cache_miss): Always blacklist pointers for free + hblks. Add assertion and comment. + * pthread_support.c (GC_register_my_thread): Fix #if indentation. + * include/private/gc_hdrs.h: USE_HDR_CACHE is no longer tested. + Delete it. + * include/private/gc_pmark.h: (PUSH_OBJ): Add assertion. + +2008-08-21 Hans Boehm + + * alloc.c, include/gc_mark.h, Makefile.direct: Improve comments. + +2008-08-01 Hans Boehm (Really Klaus Treichel) + + * configure.ac: Set win32_threads on MinGW. + * configure: Regenerate. + +2008-07-25 Hans Boehm (Really mostly Ivan Maidanski) + + Ivan's description of the patch follows. Note that a few pieces like + the GC_malloc(0) patch, were not applied since an alternate had been + previously applied. A few differed stylistically from the rest of + the code (mostly casts to void * instead of target type), + or were classified as too minor to bother. Note that + all of Ivan's static declarations which did not correct outright + naming bugs (as a few did), where replaced by STATIC, which is + ignored by default. + + - minor bug fixing (for FreeBSD, for THREAD_LOCAL_ALLOC and for + GC_malloc(0)); + - addition of missing getter/setter functions for public variables + (may be useful if compiled as Win32 DLL); + - addition of missing GC_API for some exported functions; + - addition of missing "static" declarator for internal functions + and variables (where possible); + - replacement of all remaining K&R-style definitions with ANSI + C ones (__STDC__ macro is not used anymore); + - addition of some Win32 macro definitions (that may be missing in + the standard headers supplied with a compiler) for GWW_VDB mode; + - elimination of most compiler warnings (except for + "uninitialized data" warning); + - several typos correction; + - missing parenthesis addition in macros in some header files of + "libatomic_ops" module. + + My highlights based on reading the patch: + + * allchblk.c: Remove GC_freehblk_ptr decl. + Make free_list_index_of() static. + * include/gc.h: Use __int64 on win64, define GC_oom_func, + GC_finalizer_notifier_proc, GC_finalizer_notifier_proc, + add getter and setters: GC_get_gc_no, GC_get_parallel, + GC_set_oom_fn, GC_set_finalize_on_demand, + GC_set_java_finalization, GC_set_dont_expand, + GC_set_no_dls, GC_set_max_retries, GC_set_dont_precollect, + GC_set_finalizer_notifier. Always define GC_win32_free_heap. + gc_config_macros.h: Define _REENTRANT after processing + GC_THREADS. + * include/gc_cpp.h: Improve GC_PLACEMENT_DELETE test, + handling of operator new[] for old Windows compilers. + * include/gc_inline.h (GC_MALLOC_FAST_GRANS): Add parentheses + around arguments. + * dbg_mlc.c, malloc.c, misc.c: Add many GC_API specs. + * mark.c (GC_mark_and_push_stack): Fix source argument for + blacklist printing. + * misc.c: Fix log file naming based on environment variable + for Windows. Make GC_set_warn_proc and GC_set_free_space_divisor + just return current value with 0 argument. Add DONT_USE_USER32_DLL. + Add various getters and setters as in gc.h. + * os_dep.c: Remove no longer used GC_disable/enable_signals + implementations. (GC_get_stack_base): Add pthread_attr_destroy + call. No longer set GC_old_bus_handler in DARWIN workaround. + * pthread_support.c: GC_register_my_thread must also + call GC_init_thread_local. + +2008-07-21 Hans Boehm + + * Makefile.direct, mach_dep.c: Add support for NO_GETCONTEXT. + * mach_dep.c: Include signal.h. + * gc_priv.h: Factor out INLINE declaration. + +2008-07-03 Hans Boehm (Really mostly Thiemo Seufer) + + * include/private/gcconfig.h: Update MIPS/LINUX config. + * doc/gcdescr.html: Fix typo. + * mach_dep.c (GC_with_callee_saves_pushed): Don't rely on getcontext + for MIPS/LINUX. + +2008-05-30 Hans Boehm (some really dmcmahill) + + * configure.ac: SPARC fixes. + * configure: Regenerate. + * thread_local_alloc.c(GC_mark_thread_local_fls_for): Include + size 0, except for gcj. + * doc/gc.man: Expand C++ cautions. + * include/gc_inline.h: Fix comments. + +2008-05-03 Hans Boehm + + * include/gc_version.h, configure.ac, doc/README: + Change to version 7.2alpha1. + * configure: Regenerate. + +[7.1] + +2008-05-03 Hans Boehm + + * include/gc_version.h, configure.ac, doc/README: + Change to version 7.1. + * configure: Regenerate. + +2008-05-03 Hans Boehm + + * doc/gcinterface.html: Improve C++ interface documentation. + +2008-03-10 Hans Boehm + + * allchblk.c (GC_allochblk): Check for overflow during size + rounding. + * tests/huge_test.c: New. + * Makefile.direct, tests/tests.am: Add huge_test.c + * Makefile.in: Regenerate. + +2008-02-29 Hans Boehm + + * pthread_support.c: Fix typo in comment. + * os_dep.c (GC_win32_get_mem): Add heap section only if + allocation succeeded. + +2008-02-28 Hans Boehm + + * malloc.c: (free replacement) Fix caller address space check. + +2008-02-25 Hans Boehm + + * finalize.c (GC_grow_table): Dereference table in null-check. + +2008-02-24 Hans Boehm + + * win32_threads.c (GC_delete_gc_thread, GC_delete_thread): + Consistently call CloseHandle. (GC_suspend): Call + GC_delete_gc_thread. + * tests/test.c: Don't reference GC_print_stats if not exported. + +2008-02-20 Hans Boehm + + * tests/test.c (run_one_test): Don't mention pthread_self(). + * misc.c: Declare GC_thr_init(). + +2008-02-20 Hans Boehm + + * allchblk.c (add_to_fl): disable assertions with USE_MUNMAP, + and refine assertions to handle huge unmergable blocks. + (GC_allochblk_nth): Add comment. + +2008-02-20 Hans Boehm + + * include/private/gcconfig.h: Add missing FREEBSD macro + consistency test. + +2008-02-20 Hans Boehm + + * allchblk.c (GC_enough_large_bytes_left): No longer take + parameters; return free list index bound. + (GC_merge_unmapped): Don't access nexthdr until after null test. + (Fixes bug in 1/29/08 check-in.) (GC_allochblk): Calculate + when splitting is allowable only once here, not when considering each + block. (GC_allchblk_nth): Accept new may_split parameter. + Avoid some redundant tests for exact size matches. + * alloc.c (GC_should_collect): Cache min_bytes_allocd. + (GC_maybe_gc): Make locking assertion testable. + * mark_rts.c: Fix indentation. + * pthread_stop_world.c: Replace old GC_err_printf1 reference. + * tests/test.c: Remove (void) casts. Optionally print some + timing information. + +2008-02-15 Hans Boehm + + * windows-untested/gc.def: Remove CreateThread line. + * windows-untested/README: New file. + * win32_threads.c (GC_use_DllMain): Force collector initialization. + (GC_init_parallel): Reformat comment. + * include/gc.h (GC_use_DllMain): Clarify usage rules in comment. + * mark.c (GC_mark_from): Slightly simplify GC_DS_PER_OBJECT code. + * include/gc_cpp.h: Add matching placement delete overloads + everywhere. + * include/private/gc_locks.h (NO_THREAD): Add cast. + * include/private/gcconfig.h: Add test for __HP_aCC. + * configure.ac, tests/tests.am: Avoid libgccpp on HP/UX. + * Makefile.in, configure: Regenerate. + +2008-02-11 Hans Boehm (partly David Leonard) + + * doc/README.win32: Fix typo. + * configure.ac: Fix printing of enable-shared result. + * configure: Regenerate. + +2008-02-08 Hans Boehm + + * misc.c (GC_init_inner): Assert !GC_need_to_lock only when + defined. (GC_call_with_stack_base): Add GC_API. + * os_dep.c (GC_get_stack_base): Add GC_API. + * win32_threads.c: (GC_register_my_thread, GC_unregister_my_thread): + Add GC_API. + * include/gc.h: Add GC_API annotations. + * include/private/gc_locks.h: Define UNCOND_LOCK etc. also for + PCR. + * include/private/gc_pmark.h: Fix comments. + +2008-02-06 Hans Boehm (mostly from Henning Makholm) + + * include/private/gc_priv.h, mark_rts.c, typd_mlc.c: + Add GC_push_typed_structures() to push GC_ext_descriptors. + +2008-01-31 Hans Boehm (mostly from Andreas Tobler) + + * tests/test.c: Call GC_INIT for DARWIN; test system type using + gcconfig.h-defined macros. + +2008-01-29 Hans Boehm + + * allchblk.c (GC_merge_unmapped, GC_freehblk): Refuse to create + blocks large enough that their size, when interpreted as a signed + value, would be negative. + * include/private/gc_priv.h: Comment hb_sz range limit. + +2008-01-29 Hans Boehm (with help from Manuel Serrano) + + * mark.c (GC_push_next_marked): correct comment. + * Makefile.direct: document NO_PROC_STAT. + * include/private/gcconfig.h: Accomodate NO_PROC_STAT. + +2008-01-10 Hans Boehm + + * include/gc_version.h, configure.ac, doc/README: + Change to version 7.1alpha3. + * configure: Regenerate. + +[7.1alpha2] + +2008-01-10 Hans Boehm + + * include/gc_version.h, configure.ac, doc/README: + Change to version 7.1alpha2. + * configure: Regenerate. + +2008-01-10 Hans Boehm + + * Makefile.am: Mention atomic_ops.c and atomic_ops_sysdeps.S + again. Refer to build directory as ".". + * Makefile.in: Regenerate. + +2008-01-10 Hans Boehm + + * configure.ac: Ignore --enable-parallel-mark on Darwin for now. + * configure: Regenerate. + * darwin_stop_world.c: Add FIXME comment for parallel marker. + +2008-01-09 Hans Boehm + + * include/private/gc_priv.h: Update MAX_ROOT_SETS + and LOG_PHT_ENTRIES to handle larger heaps. + +2008-01-03 Hans Boehm + + * include/gc.h (GC_INIT,GC_init): Update comments. + +2008-01-03 Hans Boehm (based on a patch from + John Bowman, and an ancient patch from Fergus Henderson) + + * allchblk.c, alloc.c, include/private/gc_priv.h: + Track GC_bytes_dropped and use in GC triggering decisions. + * alloc.c (min_bytes_allocd): Weight atomic blocks less. + +2008-01-02 Hans Boehm + + * alloc.c (GC_add_to_heap): Call GC_install_header(p) AFTER + adjusting p. + +2007-12-23 Hans Boehm + + * Makefile.am: Add NT_X64_THREADS_MAKEFILE. + +2007-12-23 Hans Boehm (Really mostly Friedrich Dominicus) + + * NT_X64_STATIC_THREADS_MAKEFILE: Clean up obsolete comment. + * alloc.c: Add declaration for GC_add_current_malloc_heap. + * win32_threads.c (GC_beginthreadex): Clean up error + return code. + * doc/README.win64, NT_X64_THREADS_MAKEFILE, Makefile.direct: + Add NT_X64_THREADS_MAKEFILE. + +2007-12-21 Hans Boehm + + * alloc.c: Define GC_version instead of in version.h. + * version.h: Remove. + * include/gc_version.h: Move most of version.h here. + * include/gc.h: Include gc_version.h. + * gcname.c, add_gc_prefix.c: include gc.h instead of version.h. + * Makefile.direct, Makefile.dj, Makefile.am, include/include.am: + Adjust for version.h rename. + * Makefile.in: Regenerate. + +2007-12-21 Hans Boehm (Really mostly russ sludge dot net) + + * configure.ac: Put libatomic_ops links in build directory. + * configure: Regenerate. + * Makefile.am: Don't mention atomic_ops.c and atomic_ops_sysdeps.S + as nodist sources. + +2007-12-20 Hans Boehm + + * include/gc.h, doc/README.macros: Add GC_NO_THREAD_REDIRECTS, + GC_NO_THREAD_DECLS, don't test explicitly for GC_SOLARIS_THREADS. + +2007-12-20 Hans Boehm + + * alloc.c: Deal correctly with address wrapping for + GC_greatest_plausible_heap_addr and GC_least_plausible_heap_addr. + * finalize.c, include/gc.h (GC_register_disappearing_link, + GC_register_finalizer_inner): Improve out-of-memory handling. + * include/private/gc_pmark.h: Fix comment spelling. + +2007-12-18 Hans Boehm (really mainly Peter Wang) + + * include/gc_inline.h, include/gc_tiny_fl.h: cleanups to make usable + in other contexts. + +2007-12-18 Hans Boehm (really Radek Polak) + + * include/gc.h: Don't define GC_HAVE_BUILTIN_BACKTRACE for uclibc. + +2007-12-18 Hans Boehm + + * gc_cpp.cc: Don't include gc_cpp.h from local directory. + +2007-12-18 Hans Boehm (really Adam Megacz) + + * allchblk.c, configure.ac (add --enable-munmap) + * configure: Regenerate. + +2007-12-10 Andreas Tobler + + * dyn_load.c (GC_dyld_image_add): Remove ifdef clause and use the macro + GC_GETSECTBYNAME instead. + * include/private/gc_priv.h: Define GC_GETSECTBYNAME according to the + architecture (Darwin). + +2007-10-24 Hans Boehm + + * reclaim.c (GC_bytes_found): Expand comment. + * thread_local_alloc.c (GC_malloc_atomic, GC_gcj_malloc): Pass + granules, not bytes, to GC_FAST_MALLOC_GRANS. + * include/gc.h: Never include gc_local_alloc.h. + * tests/test.c: Add size zero allocation tests. + +2007-10-23 Hans Boehm + + * malloc.c: Update GC_large_allocd_bytes on explicit deallocation. + * allchblk.c: Sanity check GC_max_large_allocd_bytes. + +2007-10-23 Hans Boehm (Really Manuel Serrano) + + * Makefile.direct: Invoke $(MAKE) instead of make. + +2007-10-23 Hans Boehm + + * doc/scale.html: Reflect gc7 thread local allocation behavior. + +2007-10-23 Hans Boehm (really Petter Urkedal) + + * include/extra/gc.h, include/extra/gc_cpp.h: New. + * include/include.am: Install gc.h and gc_cpp.h in $(prefix)/include + again. + * Makefile.in: Regenerate. + +2007-08-15 Hans Boehm (really Samuel Thibault) + + * pthread_support.c (GC_thr_init): Use sysconf(_SC_NPROCESSORS_ONLN) + for HURD. + +2007-08-14 Hans Boehm (really David Daney) + + * include/private/gcconfig.h: Add Linux/mips-64 support. + +2007-08-14 Hans Boehm (really mostly Samuel Thibault) + + * dbg_mlc.c: Use random() on all glibc systems. + * mach_dep.c (GC_with_callee_saves_pushed): Don't use getcontext() on + HURD. Add comment. + * pthread_stop_world.c (GC_suspend_handler, GC_stop_init): Accomodate + systems without SA_SIGINFO. + +2007-08-14 Hans Boehm (partly really Henrik Theiling) + + * include/gc.h (GC_PTR_STORE): Fix non-DEBUG parentheses. + * tests/test.c (run_one_test): Add GC_PTR_STORE test. + No longer test for RS6000. + +2007-08-03 Hans Boehm + + * alloc.c, backgraph.c, headers.c, include/private/gc_priv.h: + Maintain GC_our_memory and GC_n_memory. + * dbg_mlc.c (GC_print_smashed_obj): Improve message. + (GC_print_all_smashed_proc): Pass client object address instead of + base. + * dyn_load.c (sort_heap_sects): New. (GC_register_map_entries): + Register sections that are contiguous and merged with our heap. + * malloc.c, os_dep.c (GC_text_mapping): Check for just base name + of libraries. + * malloc.c (calloc): Check for special callers even with + USE_PROC_FOR_LIBRARIES. Move assertion. Add rudimentary + malloc/free tracing. + * misc.c: No longer call GC_init_lib_bounds explicitly. + * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Always + initialize on demand. + * tests/test.c: Call GC_INIT only when required. + +2007-08-03 Hans Boehm + + * Makefile.direct: Remove comment fragment. + * tests/tests.am: Add smashtest. + * Makefile.in: Regenerate. + * configure.ac: Define GC_USE_DLOPEN_WRAP with redirect-malloc. + * configure: Regenerate. + * pthread_support.c: Fix comment spelling. + * include/private/gcconfig.h: Define USE_PROC_FOR_LIBRARIES with + GC_LINUX_THREADS and REDIRECT_MALLOC. + * tests/smash_test.c: Initial check-in. + * obj_map.c: Print log entry to correct file. + * include/private/thread_local_alloc.h: Add TlsAlloc error check. + +2007-07-23 Hans Boehm + + * alloc.c (GC_stopped_mark): Call GC_add_current_malloc_heap() + while world is still running. + * os_dep.c (GC_is_heap_base): Don't call GC_add_current_malloc_heap() + with world stopped. + * include/gc.h (GC_INIT for cygwin): Always call GC_add_roots. + * misc.c (GC_init/GC_init_inner): Perform all work in + GC_init_inner. + * Makefile.direct: Expand -DUSE_MUNMAP comment. + +2007-07-23 Hans Boehm (really Jim Marshall) + + * include/gc.h: Define uintptr_t explicitly for VC++6. + * msvc_dbg.c (GetModuleBase): Revert to strcat if strcat_s doesn't + exist. + +2007-07-02 Hans Boehm + + * version.h, configure.ac, doc/README: Change to version 7.1alpha1. + * configure: Regenerate. + +2007-07-02 Hans Boehm + + * version.h, configure.ac, doc/README: Change to version 7.0. + * configure: Regenerate. + +2007-07-02 Hans Boehm + + * include/gc_config_macros.h: Also check for IA64 when setting + GC_HPUX_THREADS. + * mallocx.c: Change my_bytes_allocd to signed_word. + * include/gc_pthread_redirects.h: Remove obsolete Solaris threads + (as opposed to pthreads) support. + +2007-07-02 Hans Boehm + + * mach_dep.c (GC_with_callee_saves_pushed): Don't use getcontext() + on ARM/Linux. Check getcontext() return value. + +2007-06-29 Hans Boehm + + * backgraph.c (per_object_func): Make argument types consistent. + (GC_traverse_back_graph): Mark GC_deepest_obj. + +2007-06-29 Hans Boehm + + * finalize.c (GC_finalize): Change dl_size and fo_size to size_t. + * os_dep.c (GC_win32_get_mem): Add GC_mem_top_down option. + +2007-06-28 Hans Boehm + + * doc/README.win32, doc/README, README.QUICK: Fix some of the worst + anachronisms. + * dyn_load.c: Partially support cygwin, but don't enable it yet. + +2007-06-28 Hans Boehm + + * Makefile.am: Use -no-undefined for libgc. + * Makefile.in: Regenerate. + * Makefile.direct: Document USE_PROC_FOR_LIBRARIES. + * dyn_load.c (GC_register_map_entries): Rename prot_buf to prot + consistently. + * misc.c: Fix some WARN calls. Move GC_is_initialized setting and + GC_thr_init() call. + * os_dep.c: Consistently use WARN where appropriate. + * thread_local_alloc.c: Revert change to GC_WIN32_THREADS test. Instead + remove inappropriate pthread.h include. + * doc/README.linux: Remove some anachronisms. + +2007-06-23 Hans Boehm + + * alloc.c: Also use GC_check_tls on non-Linux systems. + * mallocx.c (GC_reclaim_generic): Remove bogus declaration. + * include/private/gc_priv.h (GC_reclaim_generic): Declare correctly + with prototype. + +2007-06-19 Hans Boehm + + * alloc.c (GC_adj_bytes_allocd): Avoid (long) casts, fix comment. + (GC_print_heap_sects): Use size_t instead of unsigned long. + * thread_local_alloc.c (GC_lookup_thread): Define in the correct + context. + * win32_threads.c, include/gc_config_macros.h: The last of Romano + Paolo Tenca's patch. Move stdint.h include to gc_config_macros.h. + * include/gc_inline.h: Avoid gc_priv.h dependencies. + * tests/test.c (check_heap_stats): Replace unsigned long with size_t. + +2007-06-12 Hans Boehm + + * aclocal.m4: Regenerate to update date. + +2007-06-10 Hans Boehm + + * NT_X64_STATIC_THREADS_MAKEFILE: Replace obsolete -debugtype:cv. + * mark_rts.c (GC_push_roots): Fix kind type. + +2007-06-06 Hans Boehm + + * doc/README.win64: New file. + * doc/doc.am, Makefile.direct: Add README.win64. + * Makefile.in: Regenerate. + +2007-06-06 Hans Boehm + + * Makefile.am, Makefile.direct: Add NT_X64_STATIC_THREADS_MAKEFILE. + * Makefile.in: Regenerate. + * NT_X64_STATIC_THREADS_MAKEFILE: Fix warning flags. + * allochblk.c, alloc.c, blacklst.c, dbg_mlc.c, dyn_load.c, + finalize.c, headers.c, mach_dep.c, malloc.c, mark.c, misc.c, + obj_map.c, os_dep.c, ptr_chck.c, reclaim.c, typd_mlc.c, + win32_threads.c, cord/de_win.c, include/gc_mark.h, + include/private/gc_hdrs.h, include/private/gc_pmark.h, + include/private/gc_priv.h, tests/test_cpp.cc: + Replace old style function declarations. Clean up integral types. + Remove register declarations. The change in malloc.c and the + "int descr" declaration in mark.c are the most likely to have + been real bugs outside of win64. + * msvc_dbg.c: Disable on win64. + * win32_threads.c: Add AMD64 support. + * include/gc.h: no backtrace on AMD64 for now. + +2007-06-06 Hans Boehm + + * msvc_dbg.c(GetModuleBase): Replace strcat with strcat_s. + +2007-06-06 Hans Boehm + + * include/gc.h: (GC_word, GC_signed_word): Fix win64 definitions. + Don't include windows.h in an extern "C" context. + * include/private/gcconfig.h: Fix win64/X86_64 configuration. + * tests/test.c: Eliminate more old style function definitions. + Cleanup pointer and integer casts for win64. + * tests/test_cpp.cc: Don't include gc_priv.h. + * NT_STATIC_THREADS_MAKEFILE: Restrict suffixes for VC++ 2005. + * NT_X64_STATIC_THREADS_MAKEFILE: New. + +2007-06-06 Hans Boehm (Really mostly Romano Paolo Tenca) + + * win32_threads.c: Separate out DEBUG_WIN32_PTHREADS_STACK. Ignore + FINISHED threads for suspension. (GC_pthread_join): Add + pthread_self() cast. (GC_pthread_start_inner): Execute cleanup + handler when popping it. + * include/private/gc_locks.h: Inline THREAD_EQUAL for + GC_WIN32_PTHREADS. Define USE_PTHREAD_LOCKS only if we have + pthreads. + +2007-05-23 Hans Boehm (Really mostly Romano Paolo Tenca) + + * gc_dlopen.c, thread_local_alloc.c, threadlibs.c, win32_threads.c, + tests/test.c: Accomodate GC_WIN32_PTHREADS. + * include/gc.h: Don't include windows.h for GC_WIN32_PTHREADS. + * include/gc_config_macros.h: Define both PTHREADS and + GC_WIN32_THREADS. + * include/private/gc_locks.h: Nonstandard definitions of + NUMERIC_THREAD_ID for GC_WIN32_PTHREADS. + * doc/README.win32, Makefile.direct: Include documentation + for GC_WIN32_PTHREADS. + * Makefile.direct: Remove some anachronisms in the documentation. + +2007-05-23 Hans Boehm + + * Makefile.am: Move includes to bottom. Add better library + dependencies. Increment library version. Remove "SUBDIRS += .". + * cord/cord.am, tests/tests.am: Add better library dependencies. + Remove now unnecessary dependencies. + * Makefile.in: Regenerate. + * include/gc.h (GC_beginthreadex, GC_endthreadex, GC_ExitThread): + Move to define on all Windows platforms. (_beginthread): define + to generate error if used. + +2007-05-22 Hans Boehm + + * include/private/gc_locks.h: Format to 80 columns. + +2007-05-22 Hans Boehm + + * malloc.c(GC_free): Ignore bad frees on MSWIN32 with REDIRECT_MALLOC. + * NT_MAKEFILE: msvc_dbg.h is in include/private. Don't use cvars + rc. + * misc.c (WIN32 GC_write): Define GC_need_to_lock in single-threaded + case. + * win32_threads.c: Test for __MINGW32__ in addition to _MINGW_VER. + (GC_CreateThread, GC_beginthreadex): Deallocate args even if we fail. + * include/gc.h: Add GC_reachable_here(). (GC_WinMain): Add GC_API. + (GC_beginthreadex, GC_endthreadex, GC_ExitThread): Declare. + * tests/test.c: Add GC_reachable_here() call. + +2007-05-21 Hans Boehm + + * alloc.c (GC_try_to_collect): Call GC_init if necessary. + * tests/thread_leak_test.c: Don't unconditionally define + GC_LINUX_THREADS. + +2007-05-21 Andreas Tobler + + * Makefile.am: Remove extra_ldflags_libgc definition. + * Makefile.in: Regenerate. + +2007-05-17 Hans Boehm + + * include/private/gc_priv.h: Define AO_REQUIRE_CAS. + +2007-05-16 Hans Boehm + + * finalize.c (GC_unreachable_finalize_mark_proc): Don't return void + value. + +2007-05-15 Hans Boehm + + * configure.ac, version.h, doc/README: Change version to 7.0alpha10. + * configure: Regenerate. + +[7.0alpha9 release] + +2007-05-15 Hans Boehm + + * configure.ac, version.h, doc/README: Change version to 7.0alpha9. + * configure: Regenerate. + +2007-05-15 Hans Boehm + + * Makefile.am: Include NT_STSTIC_THREADS_MAKEFILE in dist. + * Makefile.in: Regenerate. + * include/private/gc_locks.h: GC_compare_and_exchange, GC_atomic_add: + remove. NUMERIC_THREAD_ID, THREAD_EQUAL: New. GC_lock_holder: now + unsigned long. I_DONT_HOLD_LOCK, I_HOLD_LOCK: Update. + * pthread_stop_world.c, pthread_support.c, win32_threads.c: Use + NUMERIC_THREAD_ID, THREAD_EQUAL. + * include/private/gcconfig.h: GENERIC_COMPARE_AND_SWAP: Remove. + * include/private/thread_local_alloc.h: Don't USE_COMPILER_TLS on + ARM. + +2007-05-11 Hans Boehm + + * dbg_mlc.c, include/gc.h, finalize.c: Merge Alexandre Oliva's + GC_debug_register_finalizer_unreachable() patch from gcc tree. + * thread_local_alloc.c (GC_malloc, GC_malloc_atomic): Add assertions + to check GC has been initialized. + +2007-05-10 Hans Boehm + + * include/gc_cpp.h: Documentation updates. + * include/gc_config_macros.h: Don't check for __ppc__ to set + DARWIN_THREADS. + * Makefile.am: Include configure_atomic_ops.sh in dist. + * Makefile.in: Regenerate. + +2007-05-08 Hans Boehm + + * Makefile.am: Don't distribute copied atomic_ops files. Include + libatomic_ops with "make dist". + * Makefile.in: Regenerate. + * configure: Regenerate. + * configure.ac: Enable THREAD_LOCAL_ALLOC for Cygwin with threads. + * win32_threads.c: Report error for Cygwin + GC_DLL. + +2007-05-08 Hans Boehm + + * Makefile.direct: Update THREAD_LOCAL_ALLOC documentation. + * cord/de_win.c: Rename and move AboutBox. Call GC_INIT. Remove + MakeProcInstance anachronism. + * doc/README.macros: Officially remove elif prohibition. + Remove documentation for defunct SRC_M3 support. + * include/gc.h: Remove more SRC_M3 references. + * include/private/gcconfig.h: Remove still more SRC_M3 references. + GC_SOLARIS_THREADS no longer needs to be checked separately. + +2007-05-08 Hans Boehm + + * thread_local_alloc.c, include/private/thread_local_alloc.h: + Spell __declspec correctly. + * NT_STATIC_THREADS_MAKEFILE: Enable thread-local allocation. + +2007-05-07 Hans Boehm + + * doc/README.win32: Adjust GC_win32_dll_threads rules again. + +2007-05-07 Hans Boehm + + * mark.c (GC_mark_some wrapper): Restructure for readability, handle + GC_started_thread_while_stopped. + * misc.c (Win32 GC_write): Lock GC_write_cs only if needed. + * win32_threads.c: (client_has_run): remove, + GC_started_thread_while_stopped, GC_attached_thread: add. + (GC_push_all_stacks): Add verbose output. + (DllMain): Avoid initializing collector or the like. + Never update both thread tables. + * doc/README.win32: Adjust GC_win32_dll_threads rules. + +2007-05-07 Hans Boehm + + * pthread_stop_world.c (GC_push_all_stacks): Print thread count with + GC_PRINT_VERBOSE_STATS. + +2007-05-01 Hans Boehm + (and Manuel Serrano, Craig McDaniel) + + * configure.ac: Comment out redundant + AC_DEFINE(NO_EXECUTE_PERMISSION). + * configure: Regenerate. + * sparc_mach_dep.S: Remove single quote in comment. + * include/private/gcconfig.h: Fix DATAEND for NONSTOP. + * win32_threads.c: Include stdint.h for Mingw. Add GC_API for DllMain. + (GC_use_DllMain): Fix assertion. + +2007-02-14 Andreas Tobler + + * configure.ac: Introduce extra_ldflags_libgc. Use it for Darwin. + * configure: Regenerate. + * Makefile.am (libgc_la_LDFLAGS): Use extra_ldflags_libgc. + * Makefile.in: Regenerate. + * include/private/gcconfig.h: Enable MPROTECT_VDB for all Darwin + targets. Remove comments. + Prepare ppc64 support for Darwin. + +2007-01-29 Andreas Tobler + + * darwin_stop_world.c: Clean up and reformat code. + +2007-01-28 Andreas Tobler + + * darwin_stop_world.c (GC_push_all_stacks): Fix compiler warnings. + Make i unsigned. + (GC_stop_world): Likewise. Remove unused GC_thread p. + (GC_start_world): Likewise. + + * os_dep.c: Define GC_darwin_register_mach_handler_thread extern. + Remove double SIG_HNDLR_PTR definition. + (GC_forward_exception): Fix compiler warnings, make i unsigned. + Initialize thread_state to NULL. + (catch_exception_raise): Fix compiler warnings, make i unsigned. + +2007-01-25 Petr Salinger and Hans Boehm + + * include/private/gc_priv.h (NEED_FIND_LIMIT, FREEBSD variant): + also define for X86_64. + * configure.ac: Move generic gnu (Hurd) case to below kfreebsd case. + * configure: Regenerate. + * README.changes: Point to ChangeLog. + +2007-01-25 Andreas Tobler + + * darwin_stop_world.c: Move THREAD_FLD defines to ... + * include/private/gc_priv.h: ... here. + Fix THREAD_STATE definitions for ppc64. + * os_dep.c (catch_exception_raise): Use THREAD_FLD for exc_state member + access. + +2007-01-18 Andreas Tobler + + * os_dep.c (if defined(MPROTECT_VDB) && defined(DARWIN)): Clean up and + reformat code. + Correct email reference. + +2007-01-11 Andreas Tobler + + * configure.ac (i?86*-*-darwin*): Replaced HAS_I386_THREAD_STATE_* with + HAS_X86_THREAD_STATE32_*. + (x86_64-*-darwin*): Extended the above check for x86_64-*-darwin* with + HAS_X86_THREAD_STATE64_*. + Added value 1 in the above AC_DEFINE's. Important for the upcoming + Leopard. + * configure: Regenerated. + * include/private/gcconfig.h: Modified X86_64 define for Darwin. + Removed __x86_64__ check in POWERPC section. Added base definitions + for the X86_64 Darwin port. + * include/private/gc_priv.h: Added GC_MACH_HEADER and GC_MACH_SECTION + to distinguish between 32 and 64-bit applications. Added definitions + for X86_64 Darwin. + * darwin_stop_world.c: Added HAS_X86_THREAD_STATE64___RAX. And + replaced HAS_I386_THREAD_STATE___EAX with HAS_X86_THREAD_STATE32___EAX. + (GC_push_all_stacks): Added code for X86_64 Darwin. Even for the + !DARWIN_DONT_PARSE_STACK. Maybe obsolete. + * dyn_load.c (GC_dyld_name_for_hdr): Use GC_MACH_HEADER. + (GC_dyld_image_add): Use GC_MACH_HEADER and GC_MACH_SECTION. + Distinguish between getsectbynamefromheader_64 and + getsectbynamefromheader. + * os_dep.c (catch_exception_raise): Introduce exception definition for + X86_64 Darwin. Replaced old i386_EXCEPTION_STATE_* definition with + x86_EXCEPTION_STATE32_*. Add X86_64 for exc_state.faultvaddr. + +2007-01-09 Andreas Tobler + + * libtool.m4: Update to version from libtool-1.5.22. + * ltmain.sh: Likewise. + * ChangeLog: Created. + +See doc/README.changes for earlier changes.