Travis CI: Test also with Leak Sanitizer (LSan)

Move conditional GC_need_to_lock setting to gc_locks.h
(code refactoring)

* include/private/gc_locks.h [GC_PTHREADS && !THREAD_LOCAL_ALLOC
&& !USE_PTHREAD_LOCKS && !GC_ASSERTIONS] (UNCOND_LOCK): Remove
GC_ASSERT(I_DONT_HOLD_LOCK()) because it is no-op (when assertion
checking is off).
* include/private/gc_locks.h [THREADS] (set_need_to_lock): New macro.
* pthread_support.c [!GC_ALWAYS_MULTITHREADED]
(GC_allow_register_threads, WRAP_FUNC(pthread_create)): Replace
GC_need_to_lock=TRUE to set_need_to_lock().
* win32_threads.c [!GC_ALWAYS_MULTITHREADED]
(GC_allow_register_threads, GC_CreateThread, GC_init_parallel):
Likewise.
* win32_threads.c [!MSWINCE && !CYGWIN32 && !GC_ALWAYS_MULTITHREADED]
(GC_beginthreadex): Likewise.
* win32_threads.c [GC_PTHREADS && !GC_ALWAYS_MULTITHREADED]
(GC_pthread_create): Likewise.

Eliminate TSan warnings for print_proc variables assignment (gctest)

Now GC_is_valid_displacement_print_proc and GC_is_visible_print_proc
are set only once (before the first invocation of run_one_test).

* tests/test.c [DBG_HDRS_ALL] (set_print_procs): New macro (defined
to (void)0).
* tests/test.c [!DBG_HDRS_ALL] (set_print_procs): New function (which
sets GC_is_valid_displacement_print_proc and GC_is_visible_print_proc).
* tests/test.c (fail_count, fail_proc1, TEST_FAIL_COUNT): Do not
define if DBG_HDRS_ALL.
* tests/test.c [!DBG_HDRS_ALL] (run_one_test): Do not set
GC_is_valid_displacement_print_proc and GC_is_visible_print_proc.
* tests/test.c (main): Call set_print_procs() before run_one_test().
* tests/test.c [PCR] (test): Likewise.

Support GC_init (and get_stack_base) from non-main thread on FreeBSD

Issue #180 (bdwgc).

Now GC_get_[main_]stack_base uses pthread_attr_get_np() and
pthread_attr_getstack() to determine the stack base address.

* os_dep.c [FREEBSD && !NO_PTHREAD_ATTR_GET_NP && (THREADS
|| USE_GET_STACKBASE_FOR_MAIN)]: Include pthread.h and pthread_np.h.
* os_dep.c [FREEBSD && !NO_PTHREAD_ATTR_GET_NP
&& (USE_GET_STACKBASE_FOR_MAIN || THREADS && !REDIRECT_MALLOC)]
(GC_get_main_stack_base): Call pthread_attr_init, pthread_attr_get_np
and pthread_attr_getstack to determine the stack base address of the
current thread (fall back to GC_freebsd_main_stack_base in case of
failure).
* os_dep.c [(GC_FREEBSD_THREADS && !NO_PTHREAD_ATTR_GET_NP]
(GC_get_stack_base): Call pthread_attr_init, pthread_attr_get_np and
pthread_attr_getstack to determine the stack base address of the
current thread.

Fix data race in collectable_count (gctest)

* tests/test.c [THREADS && (GC_BUILTIN_ATOMIC || PARALLEL_MARK
|| !GC_WIN32_THREADS)]: Include gc_atomic_ops.h.
* tests/test.c [AO_HAVE_fetch_and_add1] (collectable_count): Change
type to volatile AO_t (and make it static to initalize it without "=0").
* tests/test.c [!AO_HAVE_fetch_and_add1] (AO_fetch_and_add1): Define
to a non-atomic increment (for a single-threaded build).
* tests/test.c (small_cons, reverse_test_inner, mktree, chktree,
alloc8bytes, typed_test, run_one_test): Use
AO_fetch_and_add1(&collectable_count) instead of collectable_count++.
* tests/test.c (check_heap_stats): Cast collectable_count to int in
GC_printf() call.

Fix missing [un]collectable_count increments in gctest

* tests/test.c [!DBG_HDRS_ALL] (run_one_test): Increment
uncollectable_count instead of collectable_count (for
GC_malloc_uncollectable(0)).
* tests/test.c [!DBG_HDRS_ALL] (run_one_test): Add missing increments
of collectable_count for GC_malloc(8) and GC_malloc(17).
* tests/test.c (run_one_test): Add missing increment of
collectable_count for (void)GC_MALLOC(0).

Eliminate '-pedantic is not option that controls warnings' GCC-6.4 message
(fix commits 84c0313, 04eb273)

* mark.c [WRAP_MARK_SOME && (MSWIN32 || MSWINCE) && __GNUC__]
(GC_mark_some): Use "-Wpedantic" instead of "-pedantic" (in pragma
GCC diagnostic) if GCC v6.4+.

Eliminate 'non-null arg compared to null' warning in toggleref_add (GCC)
(fix commit 86991cb)

* finalize.c [!GC_TOGGLE_REFS_NOT_NEEDED] (GC_toggleref_add): Use
NONNULL_ARG_NOT_NULL to check pointer argument marked as non-null (in
the function declaration) is actually non-null.

Fix pthread_detach for threads not yet registered (Cygwin, winpthreads)

* win32_threads.c [GC_PTHREADS] (GC_pthread_detach): Repeat
GC_lookup_pthread() (with a 10 msec delay) while t is null; add comment
and TODO; remove ABORT if t is null (as t is never null after
pthread_detach call).

Fix get_maps on proc maps file asynchronous growth

Issue #179 (bdwgc).

Asynchronous growth of /proc/self/maps could be caused by some thread
which is not currently registered (e.g. stack allocation on thread
creation or a non-GC heap allocation from an unregistered thread).

* os_dep.c [NEED_PROC_MAPS] (GC_get_maps): Refine comment.
* os_dep.c [NEED_PROC_MAPS && THREADS] (GC_get_maps): Replace ABORT
with WARN call; refine printed message; add comment.

Fix pthread_join when thread is registered in thread key destructor

* pthread_support.c (WRAP_FUNC(pthread_join)): Remove assertion that
thread is finished; call GC_delete_gc_thread only if thread is
finished; add comment.
* win32_threads.c [GC_PTHREADS] (GC_pthread_join): Call
GC_delete_gc_thread_no_free and GC_INTERNAL_FREE only if thread is
finished.

Fix pthread_join to avoid thread removal on failure (Cygwin, winpthreads)

* win32_threads.c [GC_WIN32_PTHREADS] (GC_pthread_join): Do not call
GC_lookup_pthread if pthread_join failed.
* win32_threads.c [GC_PTHREADS] (GC_pthread_join): Do not call
GC_delete_gc_thread_no_free, GC_INTERNAL_FREE if pthread_join failed.
* win32_threads.c [GC_PTHREADS && DEBUG_THREADS] (GC_pthread_join):
Log whether pthread_join succeeded or failed.

Fix removal of dead threads in a child process

GC_threads table may contain several elements with the same pthread id,
so GC_remove_all_threads_but_me should remove all elements except for
the first found element matching the id of the current thread.

* pthread_support.c [CAN_HANDLE_FORK] (GC_remove_all_threads_but_me):
Do not assign me if it is already non-null; add comment.
* win32_threads.c [CAN_HANDLE_FORK] (GC_remove_all_threads_but_me):
Likewise.
* win32_threads.c [CAN_HANDLE_FORK] (GC_remove_all_threads_but_me):
Remove GC_ASSERT(me==NULL).

Fix double lock in pthread_detach (Cygwin, winpthreads)

* win32_threads.c [GC_PTHREADS] (GC_pthread_detach): Do not hold the
allocation lock when GC_lookup_pthread is invoked.

Do not disable parallel mark for WRAP_MARK_SOME

Issue #179 (bdwgc).

Now, if there is a chance of unmapping of root segments, the latter
ones are scanned immediately by GC_push_roots thus preventing memory
protection faults in GC_mark_local.

* include/private/gc_priv.h (GC_PUSH_CONDITIONAL): Move definition to
mark_rts.c.
* include/private/gcconfig.h [WRAP_MARK_SOME && PARALLEL_MARK]
(PARALLEL_MARK): Do not undefine; remove TODO item.
* mark.c [WRAP_MARK_SOME && PARALLEL_MARK] (GC_push_conditional_eager):
New internal function; add TODO item.
* mark_rts.c [WRAP_MARK_SOME && PARALLEL_MARK]
(GC_push_conditional_eager): Declare function.
* mark_rts.c [WRAP_MARK_SOME && PARALLEL_MARK] (GC_PUSH_CONDITIONAL):
Define to GC_push_conditional_eager if GC_parallel.

Align local_mark_stack in help_marker explicitly

* mark.c [PARALLEL_MARK] (GC_help_marker): Declare my_id_mse local
variable (of mse type) instead of unsigned my_id; define my_id as
macro to my_id_mse.mse_descr.w; cast my_id to unsigned or int in
GC_helper_count assignment and GC_mark_local() call.

Fix thread id leaks in subthread_create and threadkey_test

* tests/subthread_create.c [GC_PTHREADS] (entry): Call pthread_detach
for the created thread.
* tests/threadkey_test.c (main): Likewise.
* tests/test.c [GC_PTHREADS && CPPCHECK] (main): Remove
UNTESTED(GC_pthread_detach).
* tests/threadkey_test.c (on_thread_exit_inner): New local variable
attr; call pthread_attr_init and pthread_attr_setdetachstate;
pass attr to GC_pthread_create; call pthread_attr_destroy.

Fix missing new-line at format strings end in subthread_create test

* tests/subthread_create.c [GC_PTHREADS] (entry, main): Append "\n" to
fprintf() format string (where missing).

Fix infinite mark_some calls after memory mapping disappeared (Glibc)

Issue #179 (bdwgc).

* mark.c [WRAP_MARK_SOME && REGISTER_LIBRARIES_EARLY] (GC_mark_some):
Call GC_cond_register_dynamic_libraries (with the world running)
before GC_invalidate_mark_state().

Fix 'undefined reference to GC_wait_for_reclaim' linker error
(fix commit f4d690e)

Issue #179 (bdwgc).

* include/private/gc_pmark.h [HAVE_CONFIG_H]: Do not include config.h
if already included from gc_priv.h (to avoid PARALLEL_MARK macro
redefinition in config.h after it was undefined in gcconfig.h).

Add TODO item to suppress 'called on pointer without debugging info'

* dbg_mlc.c [REDIRECT_FREE && USE_PROC_FOR_LIBRARIES] (GC_debug_free):
Add TODO item not to call GC_err_printf() when free() is called from
libpthread or libdl.

Eliminate 'boolean result used in bitwise op' cppcheck false warning

* extra/AmigaOS.c [GC_AMIGA_DS] (GC_register_data_segments):
Replace (ULONG)&data[1] in comparison to (ULONG)(&data[1]).
* misc.c [!THREADS && !SPARC] (GC_do_blocking_inner):
Replace (ptr_t)&d in comparison to (ptr_t)(&d).

Fix USE_GET_STACKBASE_FOR_MAIN definition in gcconfig.h

* include/private/gcconfig.h [PLATFORM_ANDROID && !THREADS]
(USE_GET_STACKBASE_FOR_MAIN): Move definition down to be after THREADS
definition.

Allow custom N_LOCAL_ITERS and ENTRIES_TO_GET values

* mark.c [PARALLEL_MARK] (N_LOCAL_ITERS): Do not define if already
defined.
* mark.c [PARALLEL_MARK] (ENTRIES_TO_GET): Likewise.

Fix missing started_thread_while_stopped call from  mark_some if GCC/Clang

* mark.c [WRAP_MARK_SOME && GC_WIN32_THREADS && !GC_PTHREADS]
(GC_started_thread_while_stopped): Declare even if __GNUC__.
* mark.c [WRAP_MARK_SOME && GC_WIN32_THREADS && (MSWIN32 || MSWINCE)]
(GC_mark_some): Invoke GC_started_thread_while_stopped (unless
GC_PTHREADS).
* win32_threads.c [WRAP_MARK_SOME && !GC_PTHREADS]
(GC_started_thread_while_stopped): Define even if __GNUC__.

Fix SIGSEGV in mark_from called from do_local_mark if WRAP_MARK_SOME

Issue #179 (bdwgc).

Parallel marker is disabled (for now) if there is a chance of
scanning unmapped data roots (because GC_do_local_mark is not
prepared to deal with memory protection faults gracefully).

* mark.c [MSWIN32 || USE_PROC_FOR_LIBRARIES] (WRAP_MARK_SOME): Move
definition to gcconfig.h.
* include/private/gcconfig.h [WRAP_MARK_SOME && PARALLEL_MARK]
(PARALLEL_MARK): Undefine (as not implemented yet).

Fix typo in 'scale' documentation file

* doc/scale.md (Options for enhanced scalability): Fix a typo
("be replaced").

Remove unnecessary type casts of printf arguments to unsigned long
(code refactoring)

* alloc.c [!NO_DEBUGGING] (GC_print_heap_sects): Remove unnecessary
cast to unsigned long in GC_*_printf call and adjust printf format
specifier to match the argument type.
* checksums.c [CHECKSUMS] (GC_checksum): Likewise.
* mark.c [PARALLEL_MARK] (GC_mark_local): Likewise.
* tests/test.c (typed_test): Likewise.
* checksums.c [CHECKSUMS] (GC_checksum): Change type of GC_n_clean,
GC_n_dirty from int to unsigned long.

Fix printf arguments type in print_callers

* os_dep.c [NEED_CALLINFO] (GC_print_callers): Cast info[i].ci_pc to
unsigned long in GC_err_printf call to match the format specifier.

Fix assertion violation in return_single_freelist in child process

Issue #171 (bdwgc).

GC_destroy_thread_local cannot be called from a thread other than
the current one.

* pthread_support.c [CAN_HANDLE_FORK && THREAD_LOCAL_ALLOC]
(GC_remove_all_threads_but_me): Do not call GC_destroy_thread_local;
add comment.
* win32_threads.c [CAN_HANDLE_FORK && THREAD_LOCAL_ALLOC]
(GC_remove_all_threads_but_me): Likewise.
* thread_local_alloc.c [THREAD_LOCAL_ALLOC] (GC_destroy_thread_local):
Update comment.

Travis CI: Test USE_CUSTOM_SPECIFIC

Fix GC_remove_specific invocation from remove_all_threads_but_me
(fix commits fcfae7f, 38e65ea)

* include/private/specific.h (GC_remove_specific): Define as macro
(calls GC_remove_specific_after_fork).
* include/private/specific.h (GC_remove_specific_after_fork): New
GC_INNER function declaration.
* include/private/thread_local_alloc.h [USE_PTHREAD_SPECIFIC
|| USE_COMPILER_TLS || USE_WIN32_COMPILER_TLS || USE_WIN32_SPECIFIC]
(GC_remove_specific_after_fork): New macro (defined to no-op).
* pthread_support.c [CAN_HANDLE_FORK && THREAD_LOCAL_ALLOC]
(GC_remove_all_threads_but_me): Call GC_remove_specific_after_fork
instead of GC_remove_specific (i.e. delete thread-specific control data
for the given thread instead of the current one).
* win32_threads.c [CAN_HANDLE_FORK && THREAD_LOCAL_ALLOC] Like
* specific.c [USE_CUSTOM_SPECIFIC] (GC_setspecific): Add assertion that
the allocation lock is held; remove the corresponding comment.
* specific.c [USE_CUSTOM_SPECIFIC] (GC_remove_specific): Replace to
GC_remove_specific_after_fork (add t argument); replace self local
variable with t argument; update comment;
* specific.c [USE_CUSTOM_SPECIFIC && CAN_HANDLE_FORK]
(GC_remove_specific_after_fork): Add assertion that the allocation lock
is held; add comment.

Eliminate 'memory leak' code defect in remove_specific

* specific.c [LINT2] (GC_remove_specific): Call GC_noop1(entry) to
indicate that entry is lost (the memory will be collected during GC).

Simplify THREAD_TABLE_INDEX expression for Win32/64
(fix commit 85fce54)

Windows thread Id rarely has non-zero highest half of DWORD, so
it is OK to use only the lowest one for hash value computation.

* win32_threads.c (THREAD_TABLE_INDEX): Remove (id>>16) from the
expression.

Add debug logging to new_thread about GC_threads hash table collisions

* pthread_support.c [DEBUG_THREADS] (GC_new_thread): Call GC_log_printf
(with the appropriate message) if a GC_threads[] entry already exists
at the given hv index (excluding the detached threads those id is
already reused).
* win32_threads.c [DEBUG_THREADS] (GC_new_thread): Call GC_log_printf
to report that a new thread is created; call GC_log_printf (with the
appropriate message) if a GC_threads[] entry already exists at the
given hv index; remove useless comment about the result of
GC_INTERNAL_MALLOC.

Eliminate most of collisions in GC_threads on Linux/x64

On some targets (e.g., Linux/x64) pthread_t values always have zero
in the lowest byte (e.g. if pthread_t is actually a page-aligned
pointer) thus causing all the created thread descriptors to have
a collision at GC_threads[0].  This commit mixes 3 lowest bytes
of thread id with a XOR operation (thus greatly reduces the
probability of collisions in GC_threads).

* include/private/pthread_support.h (THREAD_TABLE_SZ): Do not
define if already defined; refine comment.
* pthread_support.c (THREAD_TABLE_INDEX): New macro (similar to that
in win32_threads.c).
* pthread_support.c (GC_new_thread, GC_delete_thread,
GC_delete_gc_thread, GC_lookup_thread): Replace
NUMERIC_THREAD_ID(id)%THREAD_TABLE_SZ to THREAD_TABLE_INDEX(id).
* pthread_support.c (GC_lookup_thread): Remove hv local variable.
* win32_threads.c (THREAD_TABLE_INDEX): Replace (id>>2) to
((id>>16)^(id>>8)^id).
* win32_threads.c [GC_PTHREADS] (GC_lookup_pthread): Define win32_id
local variable to pass it to THREAD_TABLE_INDEX() instead of passing
GET_PTHREAD_MAP_CACHE(id) directly.

Change type of THREAD_TABLE_INDEX result to int in win32_threads.c
(code refactoring)

* win32_threads.c (THREAD_TABLE_INDEX): Cast result to int; remove cast
of argument to word type; add comment.
* win32_threads.c (GC_new_thread, GC_delete_gc_thread_no_free,
GC_delete_thread): Change type of hv local variable from word to int.
* win32_threads.c (GC_lookup_thread_inner): Remove hv local variable;
remove "register" keyword for p local variable.
* win32_threads.c (GC_lookup_pthread): Change type of hv_guess local
variable from word to int.

Fix deadlock in GC_help_marker caused by use of mark_cv of parent process

The marker threads of the parent process are blocked on mark_cv at
fork.  So pthread_cond_wait() malfunction (hang) is possible in the
child process without mark_cv state cleanup (reinitialization).

* pthread_support.c [PARALLEL_MARK] (mark_cv): Move static variable
definition upper to be before GC_start_mark_threads_inner).
* win32_threads.c [GC_PTHREADS_PARAMARK] (mark_cv): Likewise.
* pthread_support.c [PARALLEL_MARK && CAN_HANDLE_FORK] (mark_cv):
Do not initialize statically; add comment.
* win32_threads.c [GC_PTHREADS_PARAMARK && CAN_HANDLE_FORK] (mark_cv):
Likewise.
* pthread_support.c [PARALLEL_MARK && CAN_HANDLE_FORK]
(GC_start_mark_threads_inner): Initialize mark_cv to
PTHREAD_COND_INITIALIZER (unless available_markers_m1 <= 0 or
GC_parallel); add comment.
* win32_threads.c [GC_PTHREADS_PARAMARK && CAN_HANDLE_FORK]
(GC_start_mark_threads_inner): Likewise.
* pthread_support.c [PARALLEL_MARK] (GC_wait_marker,
GC_notify_all_marker): Add assertion that GC_parallel is true (so
mark_cv is initialized).
* win32_threads.c [GC_PTHREADS_PARAMARK] (GC_wait_marker,
GC_notify_all_marker): Likewise.

Travis CI: Test some --enable-munmap configurations with disable incremental collection

Avoid busy waiting in mark_thread while GC_parallel is false

* mark.c [PARALLEL_MARK] (GC_help_marker): Add assertion that
GC_parallel is true (i.e. GC_markers_m1 is non-zero).
* pthread_support.c [PARALLEL_MARK && CAN_HANDLE_FORK]
(GC_start_mark_threads_inner): Set GC_markers_m1 value before starting
the first marker thread (it is already set if fork handling is off).
* win32_threads.c [GC_PTHREADS_PARAMARK && CAN_HANDLE_FORK]
(GC_start_mark_threads_inner): Likewise.
* pthread_support.c [PARALLEL_MARK] (GC_start_mark_threads_inner):
Adjust GC_markers_m1 value only if pthread_create failed.
* win32_threads.c [GC_PTHREADS_PARAMARK] (GC_start_mark_threads_inner):
Likewise.

Eliminate unsigned fl_builder_count underflow in mark_thread
(refactor commit 0ca6d3f)

* include/private/gc_priv.h [PARALLEL_MARK] (GC_fl_builder_count):
Change type from word to signed_word.
* reclaim.c [PARALLEL_MARK] (GC_fl_builder_count): Likewise.
* mark.c [PARALLEL_MARK] (GC_wait_for_markers_init): Change type of
count local variable to signed_word; add assertion that count is
non-negative.
* pthread_support.c [PARALLEL_MARK] (GC_mark_thread): Add comment that
GC_fl_builder_count can be negative here.
* win32_threads.c [PARALLEL_MARK] (GC_mark_thread): Likewise.
* reclaim.c [PARALLEL_MARK] (GC_fl_builder_count): Refine comment.

Add assertion that no hb_n_marks underflow occurs

Issue #177 (bdwgc).

* alloc.c (GC_clear_fl_marks): Add GC_ASSERT that hhdr->hb_n_marks
is non-zero before decrementing it.
* mark.c (GC_clear_mark_bit): Likewise.

Fix hb_n_marks underflow in clear_fl_marks if MARK_BIT_PER_OBJ

Issue #177 (bdwgc).

* mark.c [MARK_BIT_PER_OBJ] (GC_set_hdr_marks): Set hhdr->hb_n_marks
exactly to n_marks value (without a decrement by one).

Use MARK_BIT_PER_GRANULE instead of MARK_BIT_PER_OBJ where appropriate
(code refactoring)

* allchblk.c (setup_header): Use "ifdef MARK_BIT_PER_GRANULE" instead
of "ifndef MARK_BIT_PER_OBJ".
* mallocx.c (GC_realloc): Likewise.

Update ChangeLog file

Update ChangeLog file (v7.6 changes only)

Update ChangeLog file (v7.2 - v7.4 changes only)

Fix visibility of __asan_default_options in case of shared library
(fix commit ce75cf1)

* os_dep.c [ADDRESS_SANITIZER && (UNIX_LIKE || NEED_FIND_LIMIT
|| MPROTECT_VDB)] (__asan_default_options): Do not define if
CUSTOM_ASAN_DEF_OPTIONS is defined; export it (use GC_API).

Eliminate '-pedantic is not an option that controls warnings' GCC message
(fix commit 84c0313)

* mark.c [WRAP_MARK_SOME && (MSWIN32 || MSWINCE) && __GNUC__]
(GC_mark_some): Use "-Wpedantic" instead of "-pedantic" (in pragma
GCC diagnostic) if GCC v7+.

Remove redundant check that clear_fl_marks argument is non-null
(code refactoring)

* alloc.c (GC_clear_fl_marks): Do not check that q is not null (because
it is checked by the caller).

Allow gctest and thread_leak_test with zero NTHREADS

* tests/test.c [GC_PTHREADS || GC_WIN32_THREADS] (reverse_test_inner):
Do not call fork_a_thread() if NTHREADS is 0.
* tests/test.c (MAX_FINALIZED): Increase to be correct for the case of
NTHREADS is 0.
* tests/test.c [GC_PTHREADS] (main): Do not declare and do not use th,
i local variables if NTHREADS is 0.
* tests/thread_leak_test.c (NTHREADS): Do not define if already defined.
* tests/thread_leak_test.c (main):  Do not declare and do not use i,
code, t, thread_id local variables if NTHREADS is 0.

Fix array_mark_proc to request global mark stack growth on overflow
(fix commit 3f06655)

* typd_mlc.c [PARALLEL_MARK] (GC_array_mark_proc): Set
GC_mark_stack_too_small to true if GC_push_complex_descriptor()
returned null and mark_stack_limit belongs to the global mark stack
(even if GC_parallel is true).

Do not call BCOPY and BZERO if size is zero

* dbg_mlc.c (GC_debug_strndup): Do not call BCOPY() if elements count
is zero.
* dbg_mlc.c (GC_debug_realloc): Likewise.
* finalize.c [!GC_TOGGLE_REFS_NOT_NEEDED] (ensure_toggleref_capacity):
Likewise.
* malloc.c [REDIRECT_MALLOC && !strndup] (strndup): Likewise.
* mallocx.c (GC_strndup): Likewise.
* misc.c [!GC_GET_HEAP_USAGE_NOT_NEEDED] (GC_get_prof_stats): Likewise.
* os_dep.c [SAVE_CALL_CHAIN && GC_HAVE_BUILTIN_BACKTRACE]
(GC_save_callers): Likewise.
* reclaim.c (GC_print_all_errors): Likewise.
* malloc.c (GC_free): Do not call BZERO() if elements count is zero.
* malloc.c [THREADS] (GC_free_inner): Likewise.
* reclaim.c (GC_print_all_errors): Likewise.
* misc.c [!GC_GET_HEAP_USAGE_NOT_NEEDED && THREADS]
(GC_get_prof_stats_unsafe): Do not call fill_prof_stats() and BCOPY()
if stats_sz is zero.

Fix leak_test crash in print_callers if free() is redirected

* dbg_mlc.c [REDIRECT_MALLOC && (GC_LINUX_THREADS || GC_SOLARIS_THREADS
|| MSWIN32 || NEED_CALLINFO && GC_HAVE_BUILTIN_BACKTRACE)]
(GC_debug_free): If the object is not in the GC heap then just return
(instead of ABORT).
* malloc.c [REDIRECT_MALLOC && NEED_CALLINFO
&& GC_HAVE_BUILTIN_BACKTRACE] (GC_free): If hhdr is null (i.e. the
object is not in the GC heap) then return without the object
deallocation; add comment.
* os_dep.c [NEED_CALLINFO && GC_HAVE_BUILTIN_BACKTRACE
&& !GC_BACKTRACE_SYMBOLS_BROKEN] (GC_print_callers): Adjust comment
for free().

Refine collect_a_little documentation (better explain when 0 is returned)

Issue #64 (bdwgc).

* include/gc.h (GC_collect_a_little): Refine comment.

Travis CI: Test configure --disable-docs

Do not install documentation if configure --disable-docs (new option)

* configure.ac (docs): New AC_ARG_ENABLE.
* configure.ac (ENABLE_DOCS): New AM_CONDITIONAL.
* doc/doc.am (dist_doc_DATA): Define only if ENABLE_DOCS.

Fix undefined HEAP_START in register_dynamic_libraries

* include/private/gcconfig.h [!HEAP_START] (HEAP_START): Define to 0 by
default (if not previously defined in the file).
* os_dep.c (HEAP_START): Remove.

Fix bytes count passed to add_to_our_memory in backgraph new_back_edges
(fix commit 180b56c)

* backgraph.c [MAKE_BACK_GRAPH] (new_back_edges): Pass bytes_to_get to
GC_add_to_our_memory() (i.e. pass the same number of bytes as passed
to GET_MEM() even in case of MMAP_SUPPORTED).

Use heap-allocated memory for local mark stack of non-marker thread

Issue #159 (bdwgc).

The memory is allocated using GET_MEM to avoid to make sure that
it is not accidentally scanned by the collector.

* include/private/gcconfig.h [!PARALLEL_MARK && THREADS]
(MIN_STACK_SIZE): Do not define.
* include/private/gcconfig.h [PARALLEL_MARK] (MIN_STACK_SIZE): Add
comment.
* mark.c [PARALLEL_MARK] (main_local_mark_stack): New static variable.
* mark.c [PARALLEL_MARK] (GC_wait_for_markers_init): Declare bytes_to_get
local variable; allocate local mark stack (using GET_MEM) and set
main_local_mark_stack (if not yet allocated by the parent process).
* mark [PARALLEL_MARK] (GC_do_parallel_mark): Remove local_mark_stack
huge local variable; use main_local_mark_stack instead of
local_mark_stack.
* pthread_support.c [GC_ASSERTIONS] (WRAP_FUNC(pthread_create)): Use
hard-coded value (65536) instead of MIN_STACK_SIZE in GC_ASSERT.
* tests/test.c [GC_PTHREADS && DEFAULT_STACK_MAYBE_SMALL]
(fork_a_thread): Do not set stack size for the created threads.
* tests/test.c [GC_PTHREADS] (main): Do not check
DEFAULT_STACK_MAYBE_SMALL.

Fix 'use' word omission in ChangeLog
(fix commit 1784ac2)

Do not use asm in GC_pause

* pthread_support.c [GC_PTHREADS && !GC_WIN32_THREADS
&& (USE_SPIN_LOCK || !NO_PTHREAD_TRYLOCK)] (GC_PAUSE_SPIN_CYCLES): New
macro.
* pthread_support.c [GC_PTHREADS && !GC_WIN32_THREADS
&& (USE_SPIN_LOCK || !NO_PTHREAD_TRYLOCK)] (GC_pause): Replace "10"
with GC_PAUSE_SPIN_CYCLES; remove "dummy" local variable; use
AO_compiler_barrier() instead of __asm__("") and GC_noop1(++dummy).

New API function (GC_is_incremental_mode)

* alloc.c (GC_is_incremental_mode): New public function definition.
* include/gc.h (GC_full_freq): Update comment.
* include/gc.h (GC_is_incremental_mode): New public function
declaration.
* tests/test.c [!GC_WIN32_THREADS && !GC_PTHREADS] (main): Print
"Switched to incremental mode" and friend messages only if
GC_is_incremental_mode().
* tests/test.c [!GC_PTHREADS] (main): Likewise.

Fix GC_incremental declaration/definition type mismatch

* alloc.c [!GC_DISABLE_INCREMENTAL] (GC_incremental): Change variable
type from int to GC_bool (to match that of the declaration in
gc_priv.h).

Fix deadlock in GC_suspend_thread when thread is rebuilding free list
(fix commits 62097c3, 59e2bcf)

* pthread_stop_world.c [GC_ENABLE_SUSPEND_THREAD] (GC_suspend_thread):
Move DISABLE_CANCEL() upper to cover also GC_wait_for_reclaim() and
RAISE_SIGNAL() calls.
* pthread_stop_world.c [GC_ENABLE_SUSPEND_THREAD && PARALLEL_MARK]
(GC_suspend_thread): If GC_parallel then call GC_wait_for_reclaim()
holding the allocation lock before RAISE_SIGNAL() call; add comment.

Workaround false 'uninitialized var use' code defect (initsecondarythread)

* tests/initsecondarythread.c [GC_PTHREADS && LINT2] (main): Initialize
"t" local variable to some value (e.g. result of pthread_create()).

Eliminate CSA warning of non-virtual destructor in test_cpp base class

* tests/test_cpp.cc (B::~B): Make the destructor virtual.

Eliminate CSA warning about incorrect cast applied to HBLK_OBJS

HBLK_OBJS() expects the argument value and has the result value of
size_t type.

* reclaim.c (GC_print_block_descr): Cast result of HBLK_OBJS() to
unsigned int instead of casting its argument.

Eliminate CSA warning about narrowing cast in CleanUp of test_cpp

* tests/test_cpp.cc (D::CleanUp): Cast self->i to word instead of
casting (word)data to int in comparison.

Eliminate CSA warning of staticroot that can be a local variable (tests)

* tests/staticrootstest.c (staticroot): Remove redundant initialization
to zero; add comment.
* tests/staticrootstest.c (init_staticroot): New function; move
staticroot=libsrl_init() from main(); add comment.
* tests/staticrootstest.c (main): Call init_staticroot().

Eliminate CSA warning of unmodified non-const static var (disclaim_test)
(fix commit 7b0be48)

* tests/disclaim_test.c (pair_magic): Make it const itself.

Do not use tkill (Android)

tkill() has been deprecated in Android.  Starting from NDK r11 (which
introduced android-23 API), the call exists only in libc.a (but not
in libc.so).  The comment in Bionic says that tkill exists only for
Mono clients (and only for 32-bit targets).

* include/private/gcconfig.h [PLATFORM_ANDROID && CPP_WORDSZ==32]
(USE_TKILL_ON_ANDROID): Do not define if __ANDROID_API__ >= 23; add
comment.

Specify that unused select() result is intentional
(fix commit 62097c3)

* pthread_stop_world.c [GC_ENABLE_SUSPEND_THREAD]
(GC_brief_async_signal_safe_sleep): Cast select() result to void.

Replace deprecated rewind to fseek in cordxtra

rewind (unlike fseek) does not report whether the operation failed.

* cord/cordxtra.c (CORD_from_file_lazy_inner, CORD_from_file_lazy,
CORD_from_file): Replace rewind(f) to fseek(f, 0l, SEEK_SET) with
error checking; adjust ABORT message in case of fseek and ftell failure.

Update AUTHORS file

Public API (GC_deinit) to allow Win32 critical sections deletion

Public GC_deinit allows the clients to avoid a leak of two critical
sections on GC shutdown.

* include/gc.h (GC_deinit): New public function declaration.
* include/private/gc_priv.h [MSWIN32 || MSWINCE] (GC_deinit): Remove.
* misc.c (GC_deinit): Make it public; define it unconditionally; call
DeleteCriticalSection(GC_allocate_ml) if GC_is_initialized; set
GC_is_initialized to false.
DeleteCriticalSection(GC_allocate_ml)
* tests/test.c [!GC_WIN32_THREADS && !GC_PTHREADS && CPPCHECK] (main):
Add UNTESTED(GC_deinit).
* win32_threads.c [GC_WINMAIN_REDIRECT && MSWINCE] (WinMain): Do not
call DeleteCriticalSection(GC_allocate_ml).
* win32_threads.c [!GC_NO_THREADS_DISCOVERY && !GC_PTHREADS]
(GC_DllMain): Likewise.

Travis CI: Test with --enable-static

Now only shared libraries are built by default.

Build only shared libraries by default (configure)

This is to speed up the build and compile all libgc source files into
a single .o file (to enable more compiler optimizations).

* configure.ac (LT_INIT): Pass disable-static; add comment.

Refactoring of USE_MMAP/USE_MMAP_ANON pairs definition in gcconfig.h

* include/private/gcconfig.h [POWERPC && (DARWIN || AIX) || NACL
|| I386 && (HURD || DARWIN) || (AARCH64 || ARM32 || X86_64) && DARWIN]
(USE_MMAP): Do not define explicitly (as USE_MMAP_ANON is defined
explicitly).
* include/private/gcconfig.h [NACL] (USE_MMAP_FIXED): Do not undefine
explicitly (as it is not defined by default).
* include/private/gcconfig.h [I386 && NACL] (HEAP_START): Do not define
value for the case of no USE_MMAP (as the latter is always defined).
* include/private/gcconfig.h [USE_MMAP_ANON && !USE_MMAP] (USE_MMAP):
Define.

Fix SIGSEGV in GC_is_marked when gc_cleanup is used in leak-finding mode

Issue #162 (bdwgc).

Now finalizers and disappearing links registration is a no-op in case
of the leak-finding mode.

*  finalize.c (GC_register_disappearing_link_inner): Do nothing (return
GC_UNIMPLEMENTED) if GC_find_leak.
* finalize.c (GC_register_finalizer_inner): Do nothing if GC_find_leak.
* include/gc.h (GC_find_leak): More verbose comment.
* include/gc.h (GC_debug_register_finalizer,
GC_general_register_disappearing_link): Document the case of
GC_find_leak.

Fix atomic_ops build in Makefile.direct for Solaris

* Makefile.direct (atomic_ops.o, atomic_ops_sysdeps.o): Expand "$<"
macro manually; add comment.

Remove name of optional arguments of operator new and new[] in gc_cpp.h
(code refactoring)

* include/gc_cpp.h (operator new): Comment out cleanup and clientData
argument names.
* include/gc_cpp.h [GC_OPERATOR_NEW_ARRAY] (operator new[]): Likewise.

Fix push_complex_descriptor to avoid unlimited global mark stack growth

Global mark stack should not grow in parallel marker mode (as
fixed-size local_mark_stack is used instead).

* typd_mlc.c [PARALLEL_MARK] (GC_array_mark_proc): Do not set
GC_mark_stack_too_small if GC_parallel (and new_mark_stack_ptr is
null); add comment.

Fix deadlock in GC_suspend_thread when thread is finished
(fix commits 62097c3, 59e2bcf)

* pthread_stop_world.c [GC_ENABLE_SUSPEND_THREAD] (GC_suspend_thread):
Do not call RAISE_SIGNAL() and sem_wait() if thread has FINISHED flag
set; do not handle ESRCH error result of RAISE_SIGNAL(); add comment.

.gitignore: Ignore .log  and .trs files for test_atomic_ops

Travis CI: Workaround 'real_malloc is never called' cppcheck warning
(fix commit 0027759)

Workaround 'GCC_ATOMIC_TEST_AND_SET_TRUEVAL unknown' cppcheck info message
(fix commit 46a2411)

* include/private/gc_atomic_ops.h [__GCC_ATOMIC_TEST_AND_SET_TRUEVAL]
(AO_TS_SET): Do not use __GCC_ATOMIC_TEST_AND_SET_TRUEVAL if CPPCHECK.

Update ChangeLog file

Update ChangeLog file (v7.6 changes only)

Update ChangeLog file (v7.2 - v7.4 changes only)

Travis CI: Change --with-checksums to --enable-checksums in CONF_OPTIONS

Rename with_checksums to enable_checksums option in CMake script
(refactoring of commit 4530166)

* CMakeLists.txt (with_checksums): Rename to enable_checksums.

Change configure --with-checksums to --enable-checksums option
(refactoring of commit bfd8345)

* configure.ac (checksums): Replace AC_ARG_WITH with AC_ARG_ENABLE;
update AS_HELP_STRING accordingly.
* configure.ac (with_checksums): Replace with enable_checksums.

windows-untested: Do not build checksums.c

Travis CI: Test --disable-munmap

Fix configure --disable-munmap handling
(fix commits d564f15, bfd8345)

* configure.ac (USE_MUNMAP, MUNMAP_THRESHOLD): Do not define if
enable_munmap is "no" (or a blank value).
* configure.ac [with_checksums=yes]: Do not report AC_MSG_ERROR if
enable_munmap is "no".

Call WARN() if GC_mprotect_dirty_init cannot succeed (Darwin)
(fix commit 6bfc840)

* os_dep.c [MPROTECT_VDB && DARWIN && CAN_HANDLE_FORK]
(GC_mprotect_dirty_init): Replace GC_COND_LOG_PRINTF() with WARN()
which is called before return FALSE; refine WARN message.

Travis CI: Test --enable-munmap with OS X

Travis CI: Test --enable-handle-fork

Decide between memory unmapping and mprotect-based dirty bits at runtime

* allchblk.c [USE_MUNMAP && MPROTECT_VDB] (GC_has_unmapped_memory): New
function.
* include/private/gcconfig.h [USE_MUNMAP] (MPROTECT_VDB): Do not
undefine unless GWW_VDB; update comment.
* os_dep.c [MPROTECT_VDB && USE_MUNMAP] (GC_has_unmapped_memory,
GC_mprotect_dirty_init): Declare function.
* os_dep.c [MPROTECT_VDB && USE_MUNMAP] (GC_dirty_init): Ensure
mprotect-based virtual dirty bits and memory unmapping are not both
turned on (disable on of them and call WARN with the appropriate
message), and call GC_mprotect_dirty_init (unless memory unmapping is
requested or some pages are already unmapped).
* os_dep.c [MPROTECT_VDB && !USE_MUNMAP] (GC_mprotect_dirty_init):
Define as a macro (to GC_dirty_init).
* os_dep.c [MPROTECT_VDB] (GC_dirty_init): Rename to
GC_mprotect_dirty_init.