Replace comments about GC is held or not with relevant assertions

(refactoring)

* alloc.c (GC_default_stop_func): Refine comment about the allocation
lock.
* alloc.c (GC_finish_collection): Remove comment that the allocation
lock is held because the assertion about it already exists.
* finalize.c (GC_grow_table, GC_mark_fo, GC_finalize): Likewise.
* finalize.c [!GC_MOVE_DISAPPEARING_LINK_NOT_NEEDED]
(GC_move_disappearing_link_inner): Likewise.
* mark.c (GC_mark_some_inner): Likewise.
* mark.c [PARALLEL_MARK] (GC_do_parallel_mark): Likewise.
* os_dep.c [OPENBSD && GC_OPENBSD_UTHREADS] (GC_find_limit_openbsd,
GC_skip_hole_openbsd): Likewise.
* os_dep.c [NEED_FIND_LIMIT || USE_PROC_FOR_LIBRARIES && THREADS]
(GC_find_limit_with_bound): Likewise.
* os_dep.c (GC_register_data_segments): Likewise.
* os_dep.c [MPROTECT_VDB || PROC_VDB || SOFT_VDB] (GC_dirty_init):
Likewise.
* pthread_stop_world.c (GC_start_world): Likewise.
* pthread_support.c (GC_new_thread): Likewise.
* thread_local_alloc.c (return_freelists): Likewise.
* win32_threads.c (GC_new_thread, GC_lookup_thread_inner,
GC_delete_gc_thread_no_free): Likewise.
* blacklst.c (GC_promote_black_lists): Remove comment that the
allocation lock is held, and add the corresponding assertion to the
beginning of the function.
* blacklst.c [!PARALLEL_MARK] (GC_add_to_black_list_normal,
GC_add_to_black_list_stack): Likewise.
* darwin_stop_world.c (GC_stop_world, GC_start_world): Likewise.
* mark_rts.c (GC_remove_root_at_pos, GC_remove_roots_inner,
GC_exclude_static_roots_inner): Likewise.
* pthread_stop_world.c (GC_push_all_stacks, GC_suspend_all): Likewise.
* pthread_support.c (GC_check_finalizer_nested): Likewise.
* thread_local_alloc.c (GC_destroy_thread_local): Likewise.
* win32_threads.c (GC_check_finalizer_nested, GC_push_all_stacks):
Likewise.
* blacklst.c (GC_is_black_listed): Refine comment about the allocation
lock.
* darwin_stop_world.c (GC_push_all_stacks): Add assertion that the lock
is held on entrance.
* gcj_mlc.c (maybe_finalize): Likewise.
* malloc.c [THREADS] (GC_free_inner): Likewise.
* dyn_load.c (GC_dyld_image_add, GC_dyld_image_remove, GC_init_dyld):
Remove comment the allocation lock should not be held, and add the
corresponding assertion to the beginning of the function.
* finalize.c (GC_invoke_finalizers): Likewise.
* mark.c [PARALLEL_MARK] (GC_help_marker): Likewise.
* pthread_support.c (GC_init_parallel): Likewise.
* win32_threads.c (GC_lookup_pthread, GC_init_parallel): Likewise.
* finalize.c (GC_finalize_all): Remove comment that the lock is not
held on entrance.
* gcj_mlc.c (GC_init_gcj_malloc): Likewise.
* typd_mlc.c (GC_add_ext_descriptor): Likewise.
* include/gc/javaxfc.h (GC_finalize_all): Add comment the function
acquires the allocation lock.
* mallocx.c (GC_generic_malloc_many): Adjust comment about GC lock.
* new_hblk.c (GC_build_fl): Likewise.
* pthread_support.c (GC_new_thread): Move the assertion about the
allocation lock closer to the beginning of the function.
* win32_threads.c (GC_new_thread): Likewise.

1 files changed, 8 insertions, 8 deletions

diff --git a/pthread_stop_world.c b/pthread_stop_world.c
index 4f7a9c78..3b0ac546 100644
--- a/pthread_stop_world.c
+++ b/pthread_stop_world.c
@@ -772,8 +772,8 @@ STATIC void GC_restart_handler(int sig)
 # undef ao_store_release_async
 #endif /* !GC_OPENBSD_UTHREADS && !NACL */
 
-/* We hold allocation lock.  Should do exactly the right thing if the   */
-/* world is stopped.  Should not fail if it isn't.                      */
+/* Should do exactly the right thing if the world is stopped; should    */
+/* not fail if it is not.                                               */
 GC_INNER void GC_push_all_stacks(void)
 {
     GC_bool found_me = FALSE;
@@ -789,6 +789,7 @@ GC_INNER void GC_push_all_stacks(void)
     pthread_t self = pthread_self();
     word total_size = 0;
 
+    GC_ASSERT(I_HOLD_LOCK());
     if (!EXPECT(GC_thr_initialized, TRUE))
       GC_thr_init();
 #   ifdef DEBUG_THREADS
@@ -910,9 +911,8 @@ GC_INNER void GC_push_all_stacks(void)
   int GC_stopping_pid = 0;
 #endif
 
-/* We hold the allocation lock.  Suspend all threads that might */
-/* still be running.  Return the number of suspend signals that */
-/* were sent.                                                   */
+/* Suspend all threads that might still be running.  Return the number  */
+/* of suspend signals that were sent.                                   */
 STATIC int GC_suspend_all(void)
 {
   int n_live_threads = 0;
@@ -925,6 +925,7 @@ STATIC int GC_suspend_all(void)
 
       GC_ASSERT((GC_stop_count & THREAD_RESTARTED) == 0);
 #   endif
+    GC_ASSERT(I_HOLD_LOCK());
     for (i = 0; i < THREAD_TABLE_SZ; i++) {
       for (p = GC_threads[i]; p != 0; p = p -> next) {
         if (!THREAD_EQUAL(p -> id, self)) {
@@ -989,6 +990,7 @@ STATIC int GC_suspend_all(void)
 #   endif
     unsigned long num_sleeps = 0;
 
+    GC_ASSERT(I_HOLD_LOCK());
 #   ifdef DEBUG_THREADS
       GC_log_printf("pthread_stop_world: number of threads: %d\n",
                     GC_nacl_num_gc_threads - 1);
@@ -1303,14 +1305,12 @@ GC_INNER void GC_stop_world(void)
   }
 #endif /* !NACL */
 
-/* Caller holds allocation lock, and has held it continuously since     */
-/* the world stopped.                                                   */
 GC_INNER void GC_start_world(void)
 {
 # ifndef NACL
     int n_live_threads;
 
-    GC_ASSERT(I_HOLD_LOCK());
+    GC_ASSERT(I_HOLD_LOCK()); /* held continuously since the world stopped */
 #   ifdef DEBUG_THREADS
       GC_log_printf("World starting\n");
 #   endif