2009-09-19 Ivan Maidanski <ivmai@mail.ru>

	* 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.

1 files changed, 246 insertions, 247 deletions

diff --git a/mark_rts.c b/mark_rts.c
index 16cfce89..4b30a716 100644
--- a/mark_rts.c
+++ b/mark_rts.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
  *
@@ -14,66 +14,66 @@
 # include <stdio.h>
 # include "private/gc_priv.h"
 
-/* Data structure for list of root sets.				*/
-/* We keep a hash table, so that we can filter out duplicate additions.	*/
-/* Under Win32, we need to do a better job of filtering overlaps, so	*/
-/* we resort to sequential search, and pay the price.			*/
+/* Data structure for list of root sets.                                */
+/* We keep a hash table, so that we can filter out duplicate additions. */
+/* Under Win32, we need to do a better job of filtering overlaps, so    */
+/* we resort to sequential search, and pay the price.                   */
 /* This is really declared in gc_priv.h:
 struct roots {
-	ptr_t r_start;
-	ptr_t r_end;
- #	if !defined(MSWIN32) && !defined(MSWINCE)
-	  struct roots * r_next;
- #	endif
-	GC_bool r_tmp;
-	  	-- Delete before registering new dynamic libraries
+        ptr_t r_start;
+        ptr_t r_end;
+ #      if !defined(MSWIN32) && !defined(MSWINCE)
+          struct roots * r_next;
+ #      endif
+        GC_bool r_tmp;
+                -- Delete before registering new dynamic libraries
 };
 
 struct roots GC_static_roots[MAX_ROOT_SETS];
 */
 
-int GC_no_dls = 0;	/* Register dynamic library data segments.	*/
+int GC_no_dls = 0;      /* Register dynamic library data segments.      */
 
 static int n_root_sets = 0;
 
-	/* GC_static_roots[0..n_root_sets) contains the valid root sets. */
+        /* GC_static_roots[0..n_root_sets) contains the valid root sets. */
 
 # if !defined(NO_DEBUGGING)
-/* For debugging:	*/
+/* For debugging:       */
 void GC_print_static_roots(void)
 {
     register int i;
     size_t total = 0;
-    
+
     for (i = 0; i < n_root_sets; i++) {
         GC_printf("From %p to %p%s\n",
-        	  GC_static_roots[i].r_start,
-        	  GC_static_roots[i].r_end,
-		  GC_static_roots[i].r_tmp ? " (temporary)" : "");
+                  GC_static_roots[i].r_start,
+                  GC_static_roots[i].r_end,
+                  GC_static_roots[i].r_tmp ? " (temporary)" : "");
         total += GC_static_roots[i].r_end - GC_static_roots[i].r_start;
     }
     GC_printf("Total size: %ld\n", (unsigned long) total);
     if (GC_root_size != total) {
-     	GC_printf("GC_root_size incorrect: %ld!!\n",
-     		  (unsigned long) GC_root_size);
+        GC_printf("GC_root_size incorrect: %ld!!\n",
+                  (unsigned long) GC_root_size);
     }
 }
 # endif /* NO_DEBUGGING */
 
-/* Primarily for debugging support:	*/
-/* Is the address p in one of the registered static			*/
-/* root sections?							*/
+/* Primarily for debugging support:     */
+/* Is the address p in one of the registered static                     */
+/* root sections?                                                       */
 GC_bool GC_is_static_root(ptr_t p)
 {
     static int last_root_set = MAX_ROOT_SETS;
     register int i;
-    
-    
+
+
     if (last_root_set < n_root_sets
-	&& p >= GC_static_roots[last_root_set].r_start
+        && p >= GC_static_roots[last_root_set].r_start
         && p < GC_static_roots[last_root_set].r_end) return(TRUE);
     for (i = 0; i < n_root_sets; i++) {
-    	if (p >= GC_static_roots[i].r_start
+        if (p >= GC_static_roots[i].r_start
             && p < GC_static_roots[i].r_end) {
             last_root_set = i;
             return(TRUE);
@@ -83,24 +83,24 @@ GC_bool GC_is_static_root(ptr_t p)
 }
 
 #if !defined(MSWIN32) && !defined(MSWINCE)
-/* 
+/*
 #   define LOG_RT_SIZE 6
 #   define RT_SIZE (1 << LOG_RT_SIZE)  -- Power of 2, may be != MAX_ROOT_SETS
 
     struct roots * GC_root_index[RT_SIZE];
-	-- Hash table header.  Used only to check whether a range is
-	-- already present.
-	-- really defined in gc_priv.h
+        -- Hash table header.  Used only to check whether a range is
+        -- already present.
+        -- really defined in gc_priv.h
 */
 
 static INLINE int rt_hash(ptr_t addr)
 {
     word result = (word) addr;
 #   if CPP_WORDSZ > 8*LOG_RT_SIZE
-	result ^= result >> 8*LOG_RT_SIZE;
+        result ^= result >> 8*LOG_RT_SIZE;
 #   endif
 #   if CPP_WORDSZ > 4*LOG_RT_SIZE
-	result ^= result >> 4*LOG_RT_SIZE;
+        result ^= result >> 4*LOG_RT_SIZE;
 #   endif
     result ^= result >> 2*LOG_RT_SIZE;
     result ^= result >> LOG_RT_SIZE;
@@ -108,13 +108,13 @@ static INLINE int rt_hash(ptr_t addr)
     return(result);
 }
 
-/* Is a range starting at b already in the table? If so return a	*/
-/* pointer to it, else NIL.						*/
+/* Is a range starting at b already in the table? If so return a        */
+/* pointer to it, else NIL.                                             */
 struct roots * GC_roots_present(ptr_t b)
 {
     int h = rt_hash(b);
     struct roots *p = GC_root_index[h];
-    
+
     while (p != 0) {
         if (p -> r_start == (ptr_t)b) return(p);
         p = p -> r_next;
@@ -126,7 +126,7 @@ struct roots * GC_roots_present(ptr_t b)
 static void add_roots_to_index(struct roots *p)
 {
     int h = rt_hash(p -> r_start);
-    
+
     p -> r_next = GC_root_index[h];
     GC_root_index[h] = p;
 }
@@ -141,7 +141,7 @@ word GC_root_size = 0;
 GC_API void GC_CALL GC_add_roots(void *b, void *e)
 {
     DCL_LOCK_STATE;
-    
+
     if (!GC_is_initialized) GC_init();
     LOCK();
     GC_add_roots_inner((ptr_t)b, (ptr_t)e, FALSE);
@@ -149,12 +149,12 @@ GC_API void GC_CALL GC_add_roots(void *b, void *e)
 }
 
 
-/* Add [b,e) to the root set.  Adding the same interval a second time	*/
-/* is a moderately fast no-op, and hence benign.  We do not handle	*/
-/* different but overlapping intervals efficiently.  (We do handle	*/
-/* them correctly.)							*/
-/* Tmp specifies that the interval may be deleted before 		*/
-/* re-registering dynamic libraries.					*/ 
+/* Add [b,e) to the root set.  Adding the same interval a second time   */
+/* is a moderately fast no-op, and hence benign.  We do not handle      */
+/* different but overlapping intervals efficiently.  (We do handle      */
+/* them correctly.)                                                     */
+/* Tmp specifies that the interval may be deleted before                */
+/* re-registering dynamic libraries.                                    */
 void GC_add_roots_inner(ptr_t b, ptr_t e, GC_bool tmp)
 {
     struct roots * old;
@@ -164,14 +164,14 @@ void GC_add_roots_inner(ptr_t b, ptr_t e, GC_bool tmp)
     e = (ptr_t)((word)e & ~(sizeof(word) - 1));
     GC_ASSERT(b <= e);
     if (b == e) return;  /* nothing to do? */
-    
+
 #   if defined(MSWIN32) || defined(MSWINCE)
-      /* Spend the time to ensure that there are no overlapping	*/
-      /* or adjacent intervals.					*/
-      /* This could be done faster with e.g. a			*/
-      /* balanced tree.  But the execution time here is		*/
-      /* virtually guaranteed to be dominated by the time it	*/
-      /* takes to scan the roots.				*/
+      /* Spend the time to ensure that there are no overlapping */
+      /* or adjacent intervals.                                 */
+      /* This could be done faster with e.g. a                  */
+      /* balanced tree.  But the execution time here is         */
+      /* virtually guaranteed to be dominated by the time it    */
+      /* takes to scan the roots.                               */
       {
         register int i;
         old = 0; /* initialized to prevent warning. */
@@ -193,7 +193,7 @@ void GC_add_roots_inner(ptr_t b, ptr_t e, GC_bool tmp)
         if (i < n_root_sets) {
           /* merge other overlapping intervals */
             struct roots *other;
-            
+
             for (i++; i < n_root_sets; i++) {
               other = GC_static_roots + i;
               b = other -> r_start;
@@ -247,7 +247,7 @@ static GC_bool roots_were_cleared = FALSE;
 GC_API void GC_CALL GC_clear_roots (void)
 {
     DCL_LOCK_STATE;
-    
+
     if (!GC_is_initialized) GC_init();
     LOCK();
     roots_were_cleared = TRUE;
@@ -255,16 +255,16 @@ GC_API void GC_CALL GC_clear_roots (void)
     GC_root_size = 0;
 #   if !defined(MSWIN32) && !defined(MSWINCE)
     {
-    	register int i;
-    	
-    	for (i = 0; i < RT_SIZE; i++) GC_root_index[i] = 0;
+        register int i;
+
+        for (i = 0; i < RT_SIZE; i++) GC_root_index[i] = 0;
     }
 #   endif
     UNLOCK();
 }
 
-/* Internal use only; lock held.	*/
-static void GC_remove_root_at_pos(int i) 
+/* Internal use only; lock held.        */
+static void GC_remove_root_at_pos(int i)
 {
     GC_root_size -= (GC_static_roots[i].r_end - GC_static_roots[i].r_start);
     GC_static_roots[i].r_start = GC_static_roots[n_root_sets-1].r_start;
@@ -277,26 +277,26 @@ static void GC_remove_root_at_pos(int i)
 static void GC_rebuild_root_index(void)
 {
     int i;
-    	
+
     for (i = 0; i < RT_SIZE; i++) GC_root_index[i] = 0;
     for (i = 0; i < n_root_sets; i++)
-	add_roots_to_index(GC_static_roots + i);
+        add_roots_to_index(GC_static_roots + i);
 }
 #endif
 
 #if defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE) \
      || defined(PCR)
-/* Internal use only; lock held.	*/
+/* Internal use only; lock held.        */
 STATIC void GC_remove_tmp_roots(void)
 {
     int i;
-    
+
     for (i = 0; i < n_root_sets; ) {
-    	if (GC_static_roots[i].r_tmp) {
+        if (GC_static_roots[i].r_tmp) {
             GC_remove_root_at_pos(i);
-    	} else {
-    	    i++;
-	}
+        } else {
+            i++;
+        }
     }
 #   if !defined(MSWIN32) && !defined(MSWINCE)
       GC_rebuild_root_index();
@@ -313,9 +313,9 @@ GC_API void GC_CALL GC_remove_roots(void *b, void *e)
 
     /* Quick check whether has nothing to do */
     if ((((word)b + (sizeof(word) - 1)) & ~(sizeof(word) - 1)) >=
-	((word)e & ~(sizeof(word) - 1)))
+        ((word)e & ~(sizeof(word) - 1)))
       return;
-    
+
     LOCK();
     GC_remove_roots_inner((ptr_t)b, (ptr_t)e);
     UNLOCK();
@@ -326,31 +326,31 @@ STATIC void GC_remove_roots_inner(ptr_t b, ptr_t e)
 {
     int i;
     for (i = 0; i < n_root_sets; ) {
-    	if (GC_static_roots[i].r_start >= b
-	    && GC_static_roots[i].r_end <= e) {
+        if (GC_static_roots[i].r_start >= b
+            && GC_static_roots[i].r_end <= e) {
             GC_remove_root_at_pos(i);
-    	} else {
-    	    i++;
-    	}
+        } else {
+            i++;
+        }
     }
     GC_rebuild_root_index();
 }
 #endif /* !defined(MSWIN32) && !defined(MSWINCE) */
 
 #if defined(MSWIN32) || defined(_WIN32_WCE_EMULATION)
-/* Workaround for the OS mapping and unmapping behind our back:		*/
-/* Is the address p in one of the temporary static root sections?	*/
+/* Workaround for the OS mapping and unmapping behind our back:         */
+/* Is the address p in one of the temporary static root sections?       */
 GC_bool GC_is_tmp_root(ptr_t p)
 {
     static int last_root_set = MAX_ROOT_SETS;
     register int i;
-    
+
     if (last_root_set < n_root_sets
-	&& p >= GC_static_roots[last_root_set].r_start
+        && p >= GC_static_roots[last_root_set].r_start
         && p < GC_static_roots[last_root_set].r_end)
-	return GC_static_roots[last_root_set].r_tmp;
+        return GC_static_roots[last_root_set].r_tmp;
     for (i = 0; i < n_root_sets; i++) {
-    	if (p >= GC_static_roots[i].r_start
+        if (p >= GC_static_roots[i].r_start
             && p < GC_static_roots[i].r_end) {
             last_root_set = i;
             return GC_static_roots[i].r_tmp;
@@ -364,9 +364,9 @@ ptr_t GC_approx_sp(void)
 {
     volatile word sp;
     sp = (word)&sp;
-		/* Also force stack to grow if necessary. Otherwise the	*/
-    		/* later accesses might cause the kernel to think we're	*/
-    		/* doing something wrong.				*/
+                /* Also force stack to grow if necessary. Otherwise the */
+                /* later accesses might cause the kernel to think we're */
+                /* doing something wrong.                               */
 
     return((ptr_t)sp);
 }
@@ -381,15 +381,15 @@ struct exclusion {
 };
 
 struct exclusion GC_excl_table[MAX_EXCLUSIONS];
-					-- Array of exclusions, ascending
-					-- address order.
+                                        -- Array of exclusions, ascending
+                                        -- address order.
 */
 
-STATIC size_t GC_excl_table_entries = 0;/* Number of entries in use.	  */
+STATIC size_t GC_excl_table_entries = 0;/* Number of entries in use.      */
 
 /* Return the first exclusion range that includes an address >= start_addr */
-/* Assumes the exclusion table contains at least one entry (namely the	   */
-/* GC data structures).							   */
+/* Assumes the exclusion table contains at least one entry (namely the     */
+/* GC data structures).                                                    */
 STATIC struct exclusion * GC_next_exclusion(ptr_t start_addr)
 {
     size_t low = 0;
@@ -397,20 +397,20 @@ STATIC struct exclusion * GC_next_exclusion(ptr_t start_addr)
     size_t mid;
 
     while (high > low) {
-	mid = (low + high) >> 1;
-	/* low <= mid < high	*/
-	if ((word) GC_excl_table[mid].e_end <= (word) start_addr) {
-	    low = mid + 1;
-	} else {
-	    high = mid;
-	}
+        mid = (low + high) >> 1;
+        /* low <= mid < high    */
+        if ((word) GC_excl_table[mid].e_end <= (word) start_addr) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
     }
     if ((word) GC_excl_table[low].e_end <= (word) start_addr) return 0;
     return GC_excl_table + low;
 }
 
-/* Should only be called when the lock is held.  The range boundaries	*/
-/* should be properly aligned and valid.				*/
+/* Should only be called when the lock is held.  The range boundaries   */
+/* should be properly aligned and valid.                                */
 void GC_exclude_static_roots_inner(void *start, void *finish)
 {
     struct exclusion * next;
@@ -420,23 +420,23 @@ void GC_exclude_static_roots_inner(void *start, void *finish)
     GC_ASSERT(start < finish);
 
     if (0 == GC_excl_table_entries) {
-	next = 0;
+        next = 0;
     } else {
-	next = GC_next_exclusion(start);
+        next = GC_next_exclusion(start);
     }
     if (0 != next) {
       if ((word)(next -> e_start) < (word) finish) {
-	/* incomplete error check. */
-	ABORT("exclusion ranges overlap");
-      }  
+        /* incomplete error check. */
+        ABORT("exclusion ranges overlap");
+      }
       if ((word)(next -> e_start) == (word) finish) {
-        /* extend old range backwards	*/
+        /* extend old range backwards   */
           next -> e_start = (ptr_t)start;
-	  return;
+          return;
       }
       next_index = next - GC_excl_table;
       for (i = GC_excl_table_entries; i > next_index; --i) {
-	GC_excl_table[i] = GC_excl_table[i-1];
+        GC_excl_table[i] = GC_excl_table[i-1];
       }
     } else {
       next_index = GC_excl_table_entries;
@@ -464,43 +464,43 @@ GC_API void GC_CALL GC_exclude_static_roots(void *b, void *e)
 /* Invoke push_conditional on ranges that are not excluded. */
 /*ARGSUSED*/
 STATIC void GC_push_conditional_with_exclusions(ptr_t bottom, ptr_t top,
-						GC_bool all)
+                                                GC_bool all)
 {
     struct exclusion * next;
     ptr_t excl_start;
 
     while (bottom < top) {
         next = GC_next_exclusion(bottom);
-	if (0 == next || (excl_start = next -> e_start) >= top) {
-	    GC_push_conditional(bottom, top, all);
-	    return;
-	}
-	if (excl_start > bottom) GC_push_conditional(bottom, excl_start, all);
-	bottom = next -> e_end;
+        if (0 == next || (excl_start = next -> e_start) >= top) {
+            GC_push_conditional(bottom, top, all);
+            return;
+        }
+        if (excl_start > bottom) GC_push_conditional(bottom, excl_start, all);
+        bottom = next -> e_end;
     }
 }
 
 #ifdef IA64
 /* Similar to GC_push_all_stack_frames() but for IA-64 registers store. */
 void GC_push_all_register_frames(ptr_t bs_lo, ptr_t bs_hi, int eager,
-			struct GC_activation_frame_s *activation_frame)
+                        struct GC_activation_frame_s *activation_frame)
 {
     while (activation_frame != NULL) {
-	ptr_t frame_bs_lo = activation_frame -> backing_store_end;
-	GC_ASSERT(frame_bs_lo <= bs_hi);
-	if (eager) {
-	    GC_push_all_eager(frame_bs_lo, bs_hi);
-	} else {
-	    GC_push_all_stack(frame_bs_lo, bs_hi);
-	}
-	bs_hi = activation_frame -> saved_backing_store_ptr;
-	activation_frame = activation_frame -> prev;
+        ptr_t frame_bs_lo = activation_frame -> backing_store_end;
+        GC_ASSERT(frame_bs_lo <= bs_hi);
+        if (eager) {
+            GC_push_all_eager(frame_bs_lo, bs_hi);
+        } else {
+            GC_push_all_stack(frame_bs_lo, bs_hi);
+        }
+        bs_hi = activation_frame -> saved_backing_store_ptr;
+        activation_frame = activation_frame -> prev;
     }
     GC_ASSERT(bs_lo <= bs_hi);
     if (eager) {
-	GC_push_all_eager(bs_lo, bs_hi);
+        GC_push_all_eager(bs_lo, bs_hi);
     } else {
-	GC_push_all_stack(bs_lo, bs_hi);
+        GC_push_all_stack(bs_lo, bs_hi);
     }
 }
 #endif /* IA64 */
@@ -508,39 +508,39 @@ void GC_push_all_register_frames(ptr_t bs_lo, ptr_t bs_hi, int eager,
 #ifdef THREADS
 
 void GC_push_all_stack_frames(ptr_t lo, ptr_t hi,
-			struct GC_activation_frame_s *activation_frame)
+                        struct GC_activation_frame_s *activation_frame)
 {
     while (activation_frame != NULL) {
-	GC_ASSERT(lo HOTTER_THAN (ptr_t)activation_frame);
-#	ifdef STACK_GROWS_UP
-	    GC_push_all_stack((ptr_t)activation_frame, lo);
-#	else /* STACK_GROWS_DOWN */
-	    GC_push_all_stack(lo, (ptr_t)activation_frame);
-#	endif
-	lo = activation_frame -> saved_stack_ptr;
-	GC_ASSERT(lo != NULL);
-	activation_frame = activation_frame -> prev;
+        GC_ASSERT(lo HOTTER_THAN (ptr_t)activation_frame);
+#       ifdef STACK_GROWS_UP
+            GC_push_all_stack((ptr_t)activation_frame, lo);
+#       else /* STACK_GROWS_DOWN */
+            GC_push_all_stack(lo, (ptr_t)activation_frame);
+#       endif
+        lo = activation_frame -> saved_stack_ptr;
+        GC_ASSERT(lo != NULL);
+        activation_frame = activation_frame -> prev;
     }
     GC_ASSERT(!(hi HOTTER_THAN lo));
 #   ifdef STACK_GROWS_UP
-	/* We got them backwards! */
-	GC_push_all_stack(hi, lo);
+        /* We got them backwards! */
+        GC_push_all_stack(hi, lo);
 #   else /* STACK_GROWS_DOWN */
-	GC_push_all_stack(lo, hi);
+        GC_push_all_stack(lo, hi);
 #   endif
 }
 
 #else /* !THREADS */
 
 # ifdef TRACE_BUF
-    /* Defined in mark.c.	*/
+    /* Defined in mark.c.       */
     void GC_add_trace_entry(char *kind, word arg1, word arg2);
 # endif
 
-			/* Similar to GC_push_all_eager, but only the	*/
-			/* part hotter than cold_gc_frame is scanned	*/
-			/* immediately.  Needed to ensure that callee-	*/
-			/* save registers are not missed.		*/
+                        /* Similar to GC_push_all_eager, but only the   */
+                        /* part hotter than cold_gc_frame is scanned    */
+                        /* immediately.  Needed to ensure that callee-  */
+                        /* save registers are not missed.               */
 /*
  * A version of GC_push_all that treats all interior pointers as valid
  * and scans part of the area immediately, to make sure that saved
@@ -553,23 +553,23 @@ void GC_push_all_stack_frames(ptr_t lo, ptr_t hi,
  * GC_dirty() call.
  */
 STATIC void GC_push_all_stack_partially_eager(ptr_t bottom, ptr_t top,
-						ptr_t cold_gc_frame)
+                                                ptr_t cold_gc_frame)
 {
   if (!NEED_FIXUP_POINTER && GC_all_interior_pointers) {
     /* Push the hot end of the stack eagerly, so that register values   */
-    /* saved inside GC frames are marked before they disappear.		*/
-    /* The rest of the marking can be deferred until later.		*/
+    /* saved inside GC frames are marked before they disappear.         */
+    /* The rest of the marking can be deferred until later.             */
     if (0 == cold_gc_frame) {
-	GC_push_all_stack(bottom, top);
-	return;
+        GC_push_all_stack(bottom, top);
+        return;
     }
     GC_ASSERT(bottom <= cold_gc_frame && cold_gc_frame <= top);
 #   ifdef STACK_GROWS_DOWN
-	GC_push_all(cold_gc_frame - sizeof(ptr_t), top);
-	GC_push_all_eager(bottom, cold_gc_frame);
+        GC_push_all(cold_gc_frame - sizeof(ptr_t), top);
+        GC_push_all_eager(bottom, cold_gc_frame);
 #   else /* STACK_GROWS_UP */
-	GC_push_all(bottom, cold_gc_frame + sizeof(ptr_t));
-	GC_push_all_eager(cold_gc_frame, top);
+        GC_push_all(bottom, cold_gc_frame + sizeof(ptr_t));
+        GC_push_all_eager(cold_gc_frame, top);
 #   endif /* STACK_GROWS_UP */
   } else {
     GC_push_all_eager(bottom, top);
@@ -579,53 +579,53 @@ STATIC void GC_push_all_stack_partially_eager(ptr_t bottom, ptr_t top,
 # endif
 }
 
-/* Similar to GC_push_all_stack_frames() but also uses cold_gc_frame.	*/
+/* Similar to GC_push_all_stack_frames() but also uses cold_gc_frame.   */
 STATIC void GC_push_all_stack_part_eager_frames(ptr_t lo, ptr_t hi,
-	ptr_t cold_gc_frame, struct GC_activation_frame_s *activation_frame)
+        ptr_t cold_gc_frame, struct GC_activation_frame_s *activation_frame)
 {
     GC_ASSERT(activation_frame == NULL || cold_gc_frame == NULL ||
-		cold_gc_frame HOTTER_THAN (ptr_t)activation_frame);
+                cold_gc_frame HOTTER_THAN (ptr_t)activation_frame);
 
     while (activation_frame != NULL) {
-	GC_ASSERT(lo HOTTER_THAN (ptr_t)activation_frame);
-#	ifdef STACK_GROWS_UP
-	    GC_push_all_stack_partially_eager((ptr_t)activation_frame, lo,
-						cold_gc_frame);
-#	else /* STACK_GROWS_DOWN */
-	    GC_push_all_stack_partially_eager(lo, (ptr_t)activation_frame,
-						cold_gc_frame);
-#	endif
-	lo = activation_frame -> saved_stack_ptr;
-	GC_ASSERT(lo != NULL);
-	activation_frame = activation_frame -> prev;
-	cold_gc_frame = NULL; /* Use at most once.	*/
+        GC_ASSERT(lo HOTTER_THAN (ptr_t)activation_frame);
+#       ifdef STACK_GROWS_UP
+            GC_push_all_stack_partially_eager((ptr_t)activation_frame, lo,
+                                                cold_gc_frame);
+#       else /* STACK_GROWS_DOWN */
+            GC_push_all_stack_partially_eager(lo, (ptr_t)activation_frame,
+                                                cold_gc_frame);
+#       endif
+        lo = activation_frame -> saved_stack_ptr;
+        GC_ASSERT(lo != NULL);
+        activation_frame = activation_frame -> prev;
+        cold_gc_frame = NULL; /* Use at most once.      */
     }
 
     GC_ASSERT(!(hi HOTTER_THAN lo));
 #   ifdef STACK_GROWS_UP
-	/* We got them backwards! */
-	GC_push_all_stack_partially_eager(hi, lo, cold_gc_frame);
+        /* We got them backwards! */
+        GC_push_all_stack_partially_eager(hi, lo, cold_gc_frame);
 #   else /* STACK_GROWS_DOWN */
-	GC_push_all_stack_partially_eager(lo, hi, cold_gc_frame);
+        GC_push_all_stack_partially_eager(lo, hi, cold_gc_frame);
 #   endif
 }
 
 # ifdef IA64
     extern word GC_save_regs_ret_val;
-			/* Previously set to backing store pointer.	*/
+                        /* Previously set to backing store pointer.     */
 # endif
 
 #endif /* !THREADS */
 
-  			/* Push enough of the current stack eagerly to	*/
-  			/* ensure that callee-save registers saved in	*/
-  			/* GC frames are scanned.			*/
-  			/* In the non-threads case, schedule entire	*/
-  			/* stack for scanning.				*/
-			/* The second argument is a pointer to the 	*/
-			/* (possibly null) thread context, for		*/
-			/* (currently hypothetical) more precise	*/
-			/* stack scanning.				*/
+                        /* Push enough of the current stack eagerly to  */
+                        /* ensure that callee-save registers saved in   */
+                        /* GC frames are scanned.                       */
+                        /* In the non-threads case, schedule entire     */
+                        /* stack for scanning.                          */
+                        /* The second argument is a pointer to the      */
+                        /* (possibly null) thread context, for          */
+                        /* (currently hypothetical) more precise        */
+                        /* stack scanning.                              */
 /*
  * In the absence of threads, push the stack contents.
  * In the presence of threads, push enough of the current stack
@@ -637,54 +637,54 @@ STATIC void GC_push_all_stack_part_eager_frames(ptr_t lo, ptr_t hi,
 STATIC void GC_push_current_stack(ptr_t cold_gc_frame, void * context)
 {
 #   if defined(THREADS)
-	if (0 == cold_gc_frame) return;
+        if (0 == cold_gc_frame) return;
 #       ifdef STACK_GROWS_DOWN
-    	  GC_push_all_eager(GC_approx_sp(), cold_gc_frame);
-	  /* For IA64, the register stack backing store is handled 	*/
-	  /* in the thread-specific code.				*/
+          GC_push_all_eager(GC_approx_sp(), cold_gc_frame);
+          /* For IA64, the register stack backing store is handled      */
+          /* in the thread-specific code.                               */
 #       else
-	  GC_push_all_eager( cold_gc_frame, GC_approx_sp() );
+          GC_push_all_eager( cold_gc_frame, GC_approx_sp() );
 #       endif
 #   else
-	GC_push_all_stack_part_eager_frames(GC_approx_sp(), GC_stackbottom,
-					cold_gc_frame, GC_activation_frame);
-#	ifdef IA64
-	      /* We also need to push the register stack backing store. */
-	      /* This should really be done in the same way as the	*/
-	      /* regular stack.  For now we fudge it a bit.		*/
-	      /* Note that the backing store grows up, so we can't use	*/
-	      /* GC_push_all_stack_partially_eager.			*/
-	      {
-		ptr_t bsp = (ptr_t) GC_save_regs_ret_val;
-	        ptr_t cold_gc_bs_pointer = bsp - 2048;
-		if (GC_all_interior_pointers &&
-		    cold_gc_bs_pointer > BACKING_STORE_BASE) {
-		  /* Adjust cold_gc_bs_pointer if below our innermost	*/
-		  /* "activation frame" in backing store.		*/
-		  if (GC_activation_frame != NULL && cold_gc_bs_pointer <
-				GC_activation_frame->backing_store_end)
-		    cold_gc_bs_pointer = GC_activation_frame->backing_store_end;
-		  GC_push_all_register_frames(BACKING_STORE_BASE,
-			cold_gc_bs_pointer, FALSE, GC_activation_frame);
-		  GC_push_all_eager(cold_gc_bs_pointer, bsp);
-		} else {
-		  GC_push_all_register_frames(BACKING_STORE_BASE, bsp,
-				TRUE /* eager */, GC_activation_frame);
-		}
-		/* All values should be sufficiently aligned that we	*/
-		/* dont have to worry about the boundary.		*/
-	      }
+        GC_push_all_stack_part_eager_frames(GC_approx_sp(), GC_stackbottom,
+                                        cold_gc_frame, GC_activation_frame);
+#       ifdef IA64
+              /* We also need to push the register stack backing store. */
+              /* This should really be done in the same way as the      */
+              /* regular stack.  For now we fudge it a bit.             */
+              /* Note that the backing store grows up, so we can't use  */
+              /* GC_push_all_stack_partially_eager.                     */
+              {
+                ptr_t bsp = (ptr_t) GC_save_regs_ret_val;
+                ptr_t cold_gc_bs_pointer = bsp - 2048;
+                if (GC_all_interior_pointers &&
+                    cold_gc_bs_pointer > BACKING_STORE_BASE) {
+                  /* Adjust cold_gc_bs_pointer if below our innermost   */
+                  /* "activation frame" in backing store.               */
+                  if (GC_activation_frame != NULL && cold_gc_bs_pointer <
+                                GC_activation_frame->backing_store_end)
+                    cold_gc_bs_pointer = GC_activation_frame->backing_store_end;
+                  GC_push_all_register_frames(BACKING_STORE_BASE,
+                        cold_gc_bs_pointer, FALSE, GC_activation_frame);
+                  GC_push_all_eager(cold_gc_bs_pointer, bsp);
+                } else {
+                  GC_push_all_register_frames(BACKING_STORE_BASE, bsp,
+                                TRUE /* eager */, GC_activation_frame);
+                }
+                /* All values should be sufficiently aligned that we    */
+                /* dont have to worry about the boundary.               */
+              }
 #       endif
 #   endif /* !THREADS */
 }
 
 void (*GC_push_typed_structures) (void) = NULL;
 
-			/* Push GC internal roots.  These are normally	*/
-			/* included in the static data segment, and 	*/
-			/* Thus implicitly pushed.  But we must do this	*/
-			/* explicitly if normal root processing is 	*/
-			/* disabled.					*/
+                        /* Push GC internal roots.  These are normally  */
+                        /* included in the static data segment, and     */
+                        /* Thus implicitly pushed.  But we must do this */
+                        /* explicitly if normal root processing is      */
+                        /* disabled.                                    */
 /*
  * Push GC internal roots.  Only called if there is some reason to believe
  * these would not otherwise get registered.
@@ -737,11 +737,11 @@ void GC_push_roots(GC_bool all, ptr_t cold_gc_frame)
      * Next push static data.  This must happen early on, since it's
      * not robust against mark stack overflow.
      */
-     /* Re-register dynamic libraries, in case one got added.		*/
-     /* There is some argument for doing this as late as possible,	*/
-     /* especially on win32, where it can change asynchronously.	*/
-     /* In those cases, we do it here.  But on other platforms, it's	*/
-     /* not safe with the world stopped, so we do it earlier.		*/
+     /* Re-register dynamic libraries, in case one got added.           */
+     /* There is some argument for doing this as late as possible,      */
+     /* especially on win32, where it can change asynchronously.        */
+     /* In those cases, we do it here.  But on other platforms, it's    */
+     /* not safe with the world stopped, so we do it earlier.           */
 #      if !defined(REGISTER_LIBRARIES_EARLY)
          GC_cond_register_dynamic_libraries();
 #      endif
@@ -749,33 +749,33 @@ void GC_push_roots(GC_bool all, ptr_t cold_gc_frame)
      /* Mark everything in static data areas                             */
        for (i = 0; i < n_root_sets; i++) {
          GC_push_conditional_with_exclusions(
-			     GC_static_roots[i].r_start,
-			     GC_static_roots[i].r_end, all);
+                             GC_static_roots[i].r_start,
+                             GC_static_roots[i].r_end, all);
        }
 
-     /* Mark all free list header blocks, if those were allocated from	*/
-     /* the garbage collected heap.  This makes sure they don't 	*/
-     /* disappear if we are not marking from static data.  It also 	*/
-     /* saves us the trouble of scanning them, and possibly that of	*/
-     /* marking the freelists.						*/
+     /* Mark all free list header blocks, if those were allocated from  */
+     /* the garbage collected heap.  This makes sure they don't         */
+     /* disappear if we are not marking from static data.  It also      */
+     /* saves us the trouble of scanning them, and possibly that of     */
+     /* marking the freelists.                                          */
        for (kind = 0; kind < GC_n_kinds; kind++) {
-	 void *base = GC_base(GC_obj_kinds[kind].ok_freelist);
-	 if (0 != base) {
-	   GC_set_mark_bit(base);
-	 }
+         void *base = GC_base(GC_obj_kinds[kind].ok_freelist);
+         if (0 != base) {
+           GC_set_mark_bit(base);
+         }
        }
-       
-     /* Mark from GC internal roots if those might otherwise have	*/
-     /* been excluded.							*/
+
+     /* Mark from GC internal roots if those might otherwise have       */
+     /* been excluded.                                                  */
        if (GC_no_dls || roots_were_cleared) {
-	   GC_push_gc_structures();
+           GC_push_gc_structures();
        }
 
-     /* Mark thread local free lists, even if their mark 	*/
-     /* descriptor excludes the link field.			*/
-     /* If the world is not stopped, this is unsafe.  It is	*/
-     /* also unnecessary, since we will do this again with the	*/
-     /* world stopped.						*/
+     /* Mark thread local free lists, even if their mark        */
+     /* descriptor excludes the link field.                     */
+     /* If the world is not stopped, this is unsafe.  It is     */
+     /* also unnecessary, since we will do this again with the  */
+     /* world stopped.                                          */
 #      if defined(THREAD_LOCAL_ALLOC)
          if (GC_world_stopped) GC_mark_thread_local_free_lists();
 #      endif
@@ -790,9 +790,8 @@ void GC_push_roots(GC_bool all, ptr_t cold_gc_frame)
       GC_push_regs_and_stack(cold_gc_frame);
 
     if (GC_push_other_roots != 0) (*GC_push_other_roots)();
-    	/* In the threads case, this also pushes thread stacks.	*/
-        /* Note that without interior pointer recognition lots	*/
-    	/* of stuff may have been pushed already, and this	*/
-    	/* should be careful about mark stack overflows.	*/
+        /* In the threads case, this also pushes thread stacks. */
+        /* Note that without interior pointer recognition lots  */
+        /* of stuff may have been pushed already, and this      */
+        /* should be careful about mark stack overflows.        */
 }
-