VM: simplified fixup_gc_workhorse::fixup_data by mering lots of functions only used...

diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp
index b6b1e4e648780b1acac97c1a4e5d7f9427cbd047..143f700b50ae6cb0f6e05170f2e80e96d4a26165 100644 (file)
--- a/vm/code_heap.cpp
+++ b/vm/code_heap.cpp
@@ -39,14 +39,6 @@ bool code_heap::uninitialized_p(code_block* compiled) {
   return uninitialized_blocks.count(compiled) > 0;
 }
 
-bool code_heap::marked_p(code_block* compiled) {
-  return allocator->state.marked_p((cell)compiled);
-}
-
-void code_heap::set_marked_p(code_block* compiled) {
-  allocator->state.set_marked_p((cell)compiled, compiled->size());
-}
-
 void code_heap::free(code_block* compiled) {
   FACTOR_ASSERT(!uninitialized_p(compiled));
   points_to_nursery.erase(compiled);

diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp
index 1b9169f69ec76666e3e117e43ee410f54784415b..4927a8c774215116dff6bd2edcdbab1cee6fb090 100644 (file)
--- a/vm/code_heap.hpp
+++ b/vm/code_heap.hpp
@@ -37,8 +37,6 @@ struct code_heap {
   void write_barrier(code_block* compiled);
   void clear_remembered_set();
   bool uninitialized_p(code_block* compiled);
-  bool marked_p(code_block* compiled);
-  void set_marked_p(code_block* compiled);
   void free(code_block* compiled);
   void flush_icache();
   void guard_safepoint();

diff --git a/vm/collector.hpp b/vm/collector.hpp
index efab4cfb197acd73efc1505ccbd188b644187344..f90dd3279a4b71078180b2909686e5d0b8ff3b50 100644 (file)
--- a/vm/collector.hpp
+++ b/vm/collector.hpp
@@ -15,18 +15,26 @@ struct gc_workhorse : no_fixup {
   gc_workhorse(factor_vm* parent, TargetGeneration* target, Policy policy)
       : parent(parent), target(target), policy(policy), code(parent->code) {}
 
-  object* resolve_forwarding(object* untagged) {
-    parent->check_data_pointer(untagged);
+  object* fixup_data(object* obj) {
+    FACTOR_ASSERT((parent->current_gc &&
+                   parent->current_gc->op == collect_growing_heap_op) ||
+                  parent->data->seg->in_segment_p((cell)obj));
+
+    if (!policy.should_copy_p(obj)) {
+      policy.visited_object(obj);
+      return obj;
+    }
 
+    object* untagged = obj;
     /* is there another forwarding pointer? */
     while (untagged->forwarding_pointer_p())
       untagged = untagged->forwarding_pointer();
 
-    /* we've found the destination */
-    return untagged;
-  }
+    if (!policy.should_copy_p(untagged)) {
+      policy.visited_object(untagged);
+      return untagged;
+    }
 
-  object* promote_object(object* untagged) {
     cell size = untagged->size();
     object* newpointer = target->allot(size);
     if (!newpointer)
@@ -40,29 +48,9 @@ struct gc_workhorse : no_fixup {
     return newpointer;
   }
 
-  object* fixup_data(object* obj) {
-    parent->check_data_pointer(obj);
-
-    if (!policy.should_copy_p(obj)) {
-      policy.visited_object(obj);
-      return obj;
-    }
-
-    object* forwarding = resolve_forwarding(obj);
-
-    if (forwarding == obj)
-      return promote_object(obj);
-    else if (policy.should_copy_p(forwarding))
-      return promote_object(forwarding);
-    else {
-      policy.visited_object(forwarding);
-      return forwarding;
-    }
-  }
-
   code_block* fixup_code(code_block* compiled) {
-    if (!code->marked_p(compiled)) {
-      code->set_marked_p(compiled);
+    if (!code->allocator->state.marked_p((cell)compiled)) {
+      code->allocator->state.set_marked_p((cell)compiled, compiled->size());
       parent->mark_stack.push_back((cell)compiled + 1);
     }
 

diff --git a/vm/debug.cpp b/vm/debug.cpp
index 7d7312231e1019310fdbeebe189a354210dd7fc4..3cba426dae038676c01e256283545a9b10b6809b 100644 (file)
--- a/vm/debug.cpp
+++ b/vm/debug.cpp
@@ -368,7 +368,7 @@ struct code_block_printer {
       reloc_size += parent->object_size(scan->relocation);
       parameter_size += parent->object_size(scan->parameters);
 
-      if (parent->code->marked_p(scan))
+      if (parent->code->allocator->state.marked_p((cell)scan))
         status = "marked";
       else
         status = "allocated";

diff --git a/vm/fixup.hpp b/vm/fixup.hpp
index fef1d6e2dcd99c1c1f73f549a44df464b3f755a7..f8fba0aaaaff6e34a16e2d47348cb07d83364e75 100644 (file)
--- a/vm/fixup.hpp
+++ b/vm/fixup.hpp
@@ -1,9 +1,5 @@
 namespace factor {
 
-template <typename T> struct identity {
-  T operator()(T t) { return t; }
-};
-
 struct no_fixup {
   static const bool translated_code_block_map = false;
 

diff --git a/vm/free_list_allocator.hpp b/vm/free_list_allocator.hpp
index 57b132b06be9f06774e7ff1a24964aa42528c116..165a65591d99891faa09a20d3fa0bce6a28837cf 100644 (file)
--- a/vm/free_list_allocator.hpp
+++ b/vm/free_list_allocator.hpp
@@ -59,7 +59,7 @@ template <typename Block>
 Block* free_list_allocator<Block>::next_allocated_block_after(Block* block) {
   while ((cell)block != this->end && block->free_p()) {
     free_heap_block* free_block = (free_heap_block*)block;
-    block = (object*)((cell)free_block + free_block->size());
+    block = (Block*)((cell)free_block + free_block->size());
   }
 
   if ((cell)block == this->end)

diff --git a/vm/full_collector.hpp b/vm/full_collector.hpp
index 0e063532b4be78dcc67aa4b97e9b3c9335e7bad8..80dd59a33b49c7dd2f5e5e0d4b891606a3b892ea 100644 (file)
--- a/vm/full_collector.hpp
+++ b/vm/full_collector.hpp
@@ -12,12 +12,12 @@ struct full_policy {
   }
 
   void promoted_object(object* obj) {
-    tenured->set_marked_p(obj);
+    tenured->state.set_marked_p((cell)obj, obj->size());
     parent->mark_stack.push_back((cell)obj);
   }
 
   void visited_object(object* obj) {
-    if (!tenured->marked_p(obj))
+    if (!tenured->state.marked_p((cell)obj))
       promoted_object(obj);
   }
 };

diff --git a/vm/tenured_space.hpp b/vm/tenured_space.hpp
index cf501f2e89a031c673ad802cb73e47f6253b9879..33ed45df47292d4fd82a62e5ece77ac378c1aa4e 100644 (file)
--- a/vm/tenured_space.hpp
+++ b/vm/tenured_space.hpp
@@ -25,14 +25,6 @@ struct tenured_space : free_list_allocator<object> {
     return (cell)next_allocated_block_after(next);
   }
 
-  bool marked_p(object* obj) {
-    return this->state.marked_p((cell)obj);
-  }
-
-  void set_marked_p(object* obj) {
-    this->state.set_marked_p((cell)obj, obj->size());
-  }
-
   void sweep() {
     free_list_allocator<object>::sweep();
     starts.update_for_sweep(&this->state);

diff --git a/vm/vm.hpp b/vm/vm.hpp
index 5014aecfc86ddaafb9b622684f7ddb361613b961..4af8511d7d03ecde6d25effbcb06f270c3335b95 100644 (file)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -382,11 +382,6 @@ struct factor_vm {
     return (Type*)allot_object(Type::type_number, size);
   }
 
-  inline void check_data_pointer(object* pointer) {
-    FACTOR_ASSERT((current_gc && current_gc->op == collect_growing_heap_op) ||
-                  data->seg->in_segment_p((cell)pointer));
-  }
-
   // generic arrays
   template <typename Array> Array* allot_uninitialized_array(cell capacity);
   template <typename Array>