VM: refactoring intended to remove trace_*-methods that are just

simple delegations to the data/code_visitor instances

vm/aging_collector.cpp

@@ -38,8 +38,8 @@ void factor_vm::collect_aging() {
     copying_collector<aging_space, aging_policy> collector(this,
                                                            this->data->aging,
                                                            aging_policy(this));
-    collector.trace_roots();
+    collector.data_visitor.visit_roots();
-    collector.trace_contexts();
+    collector.data_visitor.visit_contexts();
 
     collector.cheneys_algorithm();
 

vm/collector.hpp

@@ -107,34 +107,20 @@ template <typename TargetGeneration, typename Policy> struct collector {
         decks_scanned(0),
         code_blocks_scanned(0) {}
 
-  void trace_handle(cell* handle) { data_visitor.visit_handle(handle); }
-
   void trace_object(object* ptr) {
     data_visitor.visit_slots(ptr);
     if (ptr->type() == ALIEN_TYPE)
       ((alien*)ptr)->update_address();
   }
 
-  void trace_roots() { data_visitor.visit_roots(); }
-
-  void trace_contexts() { data_visitor.visit_contexts(); }
-
-  void trace_code_block_objects(code_block* compiled) {
-    data_visitor.visit_code_block_objects(compiled);
-  }
-
-  void trace_embedded_literals(code_block* compiled) {
-    data_visitor.visit_embedded_literals(compiled);
-  }
-
   void trace_code_heap_roots(std::set<code_block*>* remembered_set) {
     std::set<code_block*>::const_iterator iter = remembered_set->begin();
     std::set<code_block*>::const_iterator end = remembered_set->end();
 
     for (; iter != end; iter++) {
       code_block* compiled = *iter;
-      trace_code_block_objects(compiled);
+      data_visitor.visit_code_block_objects(compiled);
-      trace_embedded_literals(compiled);
+      data_visitor.visit_embedded_literals(compiled);
       compiled->flush_icache();
       code_blocks_scanned++;
     }

vm/full_collector.cpp

@@ -13,16 +13,6 @@ void full_collector::trace_code_block(code_block* compiled) {
   code_visitor.visit_embedded_code_pointers(compiled);
 }
 
-void full_collector::trace_context_code_blocks() {
-  code_visitor.visit_context_code_blocks();
-}
-
-void full_collector::trace_code_roots() { code_visitor.visit_code_roots(); }
-
-void full_collector::trace_object_code_block(object* obj) {
-  code_visitor.visit_object_code_block(obj);
-}
-
 /* After a sweep, invalidate any code heap roots which are not marked,
    so that if a block makes a tail call to a generic word, and the PIC
    compiler triggers a GC, and the caller block gets gets GCd as a result,
@@ -49,11 +39,11 @@ void factor_vm::collect_mark_impl(bool trace_contexts_p) {
   code->clear_mark_bits();
   data->tenured->clear_mark_bits();
 
-  collector.trace_roots();
+  collector.data_visitor.visit_roots();
   if (trace_contexts_p) {
-    collector.trace_contexts();
+    collector.data_visitor.visit_contexts();
-    collector.trace_context_code_blocks();
+    collector.code_visitor.visit_context_code_blocks();
-    collector.trace_code_roots();
+    collector.code_visitor.visit_code_roots();
   }
 
   while (!mark_stack.empty()) {
@@ -66,7 +56,7 @@ void factor_vm::collect_mark_impl(bool trace_contexts_p) {
     } else {
       object* obj = (object*)ptr;
       collector.trace_object(obj);
-      collector.trace_object_code_block(obj);
+      collector.code_visitor.visit_object_code_block(obj);
     }
   }
 

vm/full_collector.hpp

@@ -27,9 +27,6 @@ struct full_collector : collector<tenured_space, full_policy> {
 
   explicit full_collector(factor_vm* parent);
   void trace_code_block(code_block* compiled);
-  void trace_context_code_blocks();
-  void trace_code_roots();
-  void trace_object_code_block(object* obj);
 };
 
 }

vm/nursery_collector.cpp

@@ -9,8 +9,8 @@ void factor_vm::collect_nursery() {
                                                            this->data->aging,
                                                            nursery_policy(this));
 
-  collector.trace_roots();
+  collector.data_visitor.visit_roots();
-  collector.trace_contexts();
+  collector.data_visitor.visit_contexts();
 
   gc_event* event = current_gc->event;
 

vm/to_tenured_collector.cpp

@@ -22,8 +22,8 @@ void factor_vm::collect_to_tenured() {
 
   mark_stack.clear();
 
-  collector.trace_roots();
+  collector.data_visitor.visit_roots();
-  collector.trace_contexts();
+  collector.data_visitor.visit_contexts();
 
   gc_event* event = current_gc->event;