Initial revision

1 files changed, 484 insertions, 0 deletions

diff --git a/gc/mark_rts.c b/gc/mark_rts.c
new file mode 100644
index 0000000..2f21ed3
--- /dev/null
+++ b/gc/mark_rts.c
@@ -0,0 +1,484 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+/* Boehm, October 9, 1995 1:06 pm PDT */
+# include <stdio.h>
+# include "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.			*/
+/* This is really declared in gc_priv.h:
+struct roots {
+	ptr_t r_start;
+	ptr_t r_end;
+ #	ifndef MSWIN32
+	  struct roots * r_next;
+ #	endif
+	GC_bool r_tmp;
+	  	-- Delete before registering new dynamic libraries
+};
+
+struct roots GC_static_roots[MAX_ROOT_SETS];
+*/
+
+static int n_root_sets = 0;
+
+	/* GC_static_roots[0..n_root_sets) contains the valid root sets. */
+
+# if !defined(NO_DEBUGGING)
+/* For debugging:	*/
+void GC_print_static_roots()
+{
+    register int i;
+    size_t total = 0;
+    
+    for (i = 0; i < n_root_sets; i++) {
+        GC_printf2("From 0x%lx to 0x%lx ",
+        	   (unsigned long) GC_static_roots[i].r_start,
+        	   (unsigned long) GC_static_roots[i].r_end);
+        if (GC_static_roots[i].r_tmp) {
+            GC_printf0(" (temporary)\n");
+        } else {
+            GC_printf0("\n");
+        }
+        total += GC_static_roots[i].r_end - GC_static_roots[i].r_start;
+    }
+    GC_printf1("Total size: %ld\n", (unsigned long) total);
+    if (GC_root_size != total) {
+     	GC_printf1("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?							*/
+GC_bool GC_is_static_root(p)
+ptr_t p;
+{
+    static int last_root_set = 0;
+    register int i;
+    
+    
+    if (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
+            && p < GC_static_roots[i].r_end) {
+            last_root_set = i;
+            return(TRUE);
+        }
+    }
+    return(FALSE);
+}
+
+#ifndef MSWIN32
+/* 
+#   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
+*/
+
+static int rt_hash(addr)
+char * addr;
+{
+    word result = (word) addr;
+#   if CPP_WORDSZ > 8*LOG_RT_SIZE
+	result ^= result >> 8*LOG_RT_SIZE;
+#   endif
+#   if CPP_WORDSZ > 4*LOG_RT_SIZE
+	result ^= result >> 4*LOG_RT_SIZE;
+#   endif
+    result ^= result >> 2*LOG_RT_SIZE;
+    result ^= result >> LOG_RT_SIZE;
+    result &= (RT_SIZE-1);
+    return(result);
+}
+
+/* Is a range starting at b already in the table? If so return a	*/
+/* pointer to it, else NIL.						*/
+struct roots * GC_roots_present(b)
+char *b;
+{
+    register int h = rt_hash(b);
+    register struct roots *p = GC_root_index[h];
+    
+    while (p != 0) {
+        if (p -> r_start == (ptr_t)b) return(p);
+        p = p -> r_next;
+    }
+    return(FALSE);
+}
+
+/* Add the given root structure to the index. */
+static void add_roots_to_index(p)
+struct roots *p;
+{
+    register int h = rt_hash(p -> r_start);
+    
+    p -> r_next = GC_root_index[h];
+    GC_root_index[h] = p;
+}
+
+# else /* MSWIN32 */
+
+#   define add_roots_to_index(p)
+
+# endif
+
+
+
+
+word GC_root_size = 0;
+
+void GC_add_roots(b, e)
+char * b; char * e;
+{
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    GC_add_roots_inner(b, e, FALSE);
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+
+
+/* Add [b,e) to the root set.  Adding the same interval a second time	*/
+/* is a moderately fast noop, 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 		*/
+/* reregistering dynamic libraries.					*/ 
+void GC_add_roots_inner(b, e, tmp)
+char * b; char * e;
+GC_bool tmp;
+{
+    struct roots * old;
+    
+#   ifdef MSWIN32
+      /* 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;
+        
+        for (i = 0; i < n_root_sets; i++) {
+            old = GC_static_roots + i;
+            if ((ptr_t)b <= old -> r_end && (ptr_t)e >= old -> r_start) {
+                if ((ptr_t)b < old -> r_start) {
+                    old -> r_start = (ptr_t)b;
+                    GC_root_size += (old -> r_start - (ptr_t)b);
+                }
+                if ((ptr_t)e > old -> r_end) {
+                    old -> r_end = (ptr_t)e;
+                    GC_root_size += ((ptr_t)e - old -> r_end);
+                }
+                old -> r_tmp &= tmp;
+                break;
+            }
+        }
+        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 = (char *)(other -> r_start);
+              e = (char *)(other -> r_end);
+              if ((ptr_t)b <= old -> r_end && (ptr_t)e >= old -> r_start) {
+                if ((ptr_t)b < old -> r_start) {
+                    old -> r_start = (ptr_t)b;
+                    GC_root_size += (old -> r_start - (ptr_t)b);
+                }
+                if ((ptr_t)e > old -> r_end) {
+                    old -> r_end = (ptr_t)e;
+                    GC_root_size += ((ptr_t)e - old -> r_end);
+                }
+                old -> r_tmp &= other -> r_tmp;
+                /* Delete this entry. */
+                  GC_root_size -= (other -> r_end - other -> r_start);
+                  other -> r_start = GC_static_roots[n_root_sets-1].r_start;
+                  other -> r_end = GC_static_roots[n_root_sets-1].r_end;
+                                  n_root_sets--;
+              }
+            }
+          return;
+        }
+      }
+#   else
+      old = GC_roots_present(b);
+      if (old != 0) {
+        if ((ptr_t)e <= old -> r_end) /* already there */ return;
+        /* else extend */
+        GC_root_size += (ptr_t)e - old -> r_end;
+        old -> r_end = (ptr_t)e;
+        return;
+      }
+#   endif
+    if (n_root_sets == MAX_ROOT_SETS) {
+        ABORT("Too many root sets\n");
+    }
+    GC_static_roots[n_root_sets].r_start = (ptr_t)b;
+    GC_static_roots[n_root_sets].r_end = (ptr_t)e;
+    GC_static_roots[n_root_sets].r_tmp = tmp;
+#   ifndef MSWIN32
+      GC_static_roots[n_root_sets].r_next = 0;
+#   endif
+    add_roots_to_index(GC_static_roots + n_root_sets);
+    GC_root_size += (ptr_t)e - (ptr_t)b;
+    n_root_sets++;
+}
+
+void GC_clear_roots GC_PROTO((void))
+{
+    DCL_LOCK_STATE;
+    
+    DISABLE_SIGNALS();
+    LOCK();
+    n_root_sets = 0;
+    GC_root_size = 0;
+#   ifndef MSWIN32
+    {
+    	register int i;
+    	
+    	for (i = 0; i < RT_SIZE; i++) GC_root_index[i] = 0;
+    }
+#   endif
+    UNLOCK();
+    ENABLE_SIGNALS();
+}
+
+/* Internal use only; lock held.	*/
+void GC_remove_tmp_roots()
+{
+    register int i;
+    
+    for (i = 0; i < n_root_sets; ) {
+    	if (GC_static_roots[i].r_tmp) {
+    	    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;
+    	    GC_static_roots[i].r_end = GC_static_roots[n_root_sets-1].r_end;
+    	    GC_static_roots[i].r_tmp = GC_static_roots[n_root_sets-1].r_tmp;
+    	    n_root_sets--;
+    	} else {
+    	    i++;
+    	}
+    }
+#   ifndef MSWIN32
+    {
+    	register 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);
+    }
+#   endif
+    
+}
+
+ptr_t GC_approx_sp()
+{
+    word dummy;
+    
+    return((ptr_t)(&dummy));
+}
+
+/*
+ * Data structure for excluded static roots.
+ * Real declaration is in gc_priv.h.
+
+struct exclusion {
+    ptr_t e_start;
+    ptr_t e_end;
+};
+
+struct exclusion GC_excl_table[MAX_EXCLUSIONS];
+					-- Array of exclusions, ascending
+					-- address order.
+*/
+
+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).							   */
+struct exclusion * GC_next_exclusion(start_addr)
+ptr_t start_addr;
+{
+    size_t low = 0;
+    size_t high = GC_excl_table_entries - 1;
+    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;
+	}
+    }
+    if ((word) GC_excl_table[low].e_end <= (word) start_addr) return 0;
+    return GC_excl_table + low;
+}
+
+void GC_exclude_static_roots(start, finish)
+GC_PTR start;
+GC_PTR finish;
+{
+    struct exclusion * next;
+    size_t next_index, i;
+
+    if (0 == GC_excl_table_entries) {
+	next = 0;
+    } else {
+	next = GC_next_exclusion(start);
+    }
+    if (0 != next) {
+      if ((word)(next -> e_start) < (word) finish) {
+	/* incomplete error check. */
+	ABORT("exclusion ranges overlap");
+      }  
+      if ((word)(next -> e_start) == (word) finish) {
+        /* extend old range backwards	*/
+          next -> e_start = (ptr_t)start;
+	  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];
+      }
+    } else {
+      next_index = GC_excl_table_entries;
+    }
+    if (GC_excl_table_entries == MAX_EXCLUSIONS) ABORT("Too many exclusions");
+    GC_excl_table[next_index].e_start = (ptr_t)start;
+    GC_excl_table[next_index].e_end = (ptr_t)finish;
+    ++GC_excl_table_entries;
+}
+
+/* Invoke push_conditional on ranges that are not excluded. */
+void GC_push_conditional_with_exclusions(bottom, top, all)
+ptr_t bottom;
+ptr_t top;
+int 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;
+    }
+}
+
+/*
+ * In the absence of threads, push the stack contents.
+ * In the presence of threads, push enough of the current stack
+ * to ensure that callee-save registers saved in collector frames have been
+ * seen.
+ */
+void GC_push_current_stack(cold_gc_frame)
+ptr_t cold_gc_frame;
+{
+#   if defined(THREADS)
+	if (0 == cold_gc_frame) return;
+#       ifdef STACK_GROWS_DOWN
+    	  GC_push_all_eager(GC_approx_sp(), cold_gc_frame);
+#       else
+	  GC_push_all_eager( cold_gc_frame, GC_approx_sp() );
+#       endif
+#   else
+#   	ifdef STACK_GROWS_DOWN
+    	    GC_push_all_stack_partially_eager( GC_approx_sp(), GC_stackbottom,
+					       cold_gc_frame );
+#       else
+	    GC_push_all_stack_partially_eager( GC_stackbottom, GC_approx_sp(),
+					       cold_gc_frame );
+#       endif
+#   endif /* !THREADS */
+}
+
+/*
+ * Call the mark routines (GC_tl_push for a single pointer, GC_push_conditional
+ * on groups of pointers) on every top level accessible pointer.
+ * If all is FALSE, arrange to push only possibly altered values.
+ * Cold_gc_frame is an address inside a GC frame that
+ * remains valid until all marking is complete.
+ * A zero value indicates that it's OK to miss some
+ * register values.
+ */
+void GC_push_roots(all, cold_gc_frame)
+GC_bool all;
+ptr_t cold_gc_frame;
+{
+    register int i;
+
+    /*
+     * push registers - i.e., call GC_push_one(r) for each
+     * register contents r.
+     */
+#   ifdef USE_GENERIC_PUSH_REGS
+	GC_generic_push_regs(cold_gc_frame);
+#   else
+        GC_push_regs(); /* usually defined in machine_dep.c */
+#   endif
+        
+    /*
+     * Next push static data.  This must happen early on, since it's
+     * not robust against mark stack overflow.
+     */
+     /* Reregister dynamic libraries, in case one got added.	*/
+#      if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(PCR)) \
+           && !defined(SRC_M3)
+         GC_remove_tmp_roots();
+         GC_register_dynamic_libraries();
+#      endif
+     /* 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);
+       }
+
+    /*
+     * Now traverse stacks.
+     */
+#   if !defined(USE_GENERIC_PUSH_REGS)
+	GC_push_current_stack(cold_gc_frame);
+	/* IN the threads case, this only pushes collector frames.      */
+	/* In the USE_GENERIC_PUSH_REGS case, this is done inside	*/
+	/* GC_push_regs, so that we catch callee-save registers saved	*/
+	/* inside the GC_push_regs frame.				*/
+#   endif
+    if (GC_push_other_roots != 0) (*GC_push_other_roots)();
+    	/* In the threads case, this also pushes thread stacks.	*/
+}
+