vm: clean up code heap visitor

vm/code_block_visitor.hpp

@@ -19,44 +19,6 @@ template<typename Visitor> struct call_frame_code_block_visitor {
 	}
 };
 
-template<typename Visitor> void factor_vm::visit_object_code_block(object *obj, Visitor visitor)
-{
-	switch(obj->h.hi_tag())
-	{
-	case WORD_TYPE:
-		{
-			word *w = (word *)obj;
-			if(w->code)
-				w->code = visitor(w->code);
-			if(w->profiling)
-				w->code = visitor(w->profiling);
-
-			update_word_xt(w);
-			break;
-		}
-	case QUOTATION_TYPE:
-		{
-			quotation *q = (quotation *)obj;
-			if(q->code)
-				set_quot_xt(q,visitor(q->code));
-			break;
-		}
-	case CALLSTACK_TYPE:
-		{
-			callstack *stack = (callstack *)obj;
-			call_frame_code_block_visitor<Visitor> call_frame_visitor(this,visitor);
-			iterate_callstack_object(stack,call_frame_visitor);
-			break;
-		}
-	}
-}
-
-template<typename Visitor> void factor_vm::visit_context_code_blocks(Visitor visitor)
-{
-	call_frame_code_block_visitor<Visitor> call_frame_visitor(this,visitor);
-	iterate_active_frames(call_frame_visitor);
-}
-
 template<typename Visitor> struct callback_code_block_visitor {
 	callback_heap *callbacks;
 	Visitor visitor;
@@ -71,10 +33,56 @@ template<typename Visitor> struct callback_code_block_visitor {
 	}
 };
 
-template<typename Visitor> void factor_vm::visit_callback_code_blocks(Visitor visitor)
+template<typename Visitor> struct code_block_visitor {
+	factor_vm *parent;
+	Visitor visitor;
+
+	explicit code_block_visitor(factor_vm *parent_, Visitor visitor_) :
+		parent(parent_), visitor(visitor_) {}
+	void visit_object_code_block(object *obj)
 	{
-	callback_code_block_visitor<Visitor> callback_visitor(callbacks,visitor);
+		switch(obj->h.hi_tag())
-	callbacks->iterate(callback_visitor);
+		{
+		case WORD_TYPE:
+			{
+				word *w = (word *)obj;
+				if(w->code)
+					w->code = visitor(w->code);
+				if(w->profiling)
+					w->code = visitor(w->profiling);
+	
+				parent->update_word_xt(w);
+				break;
+			}
+		case QUOTATION_TYPE:
+			{
+				quotation *q = (quotation *)obj;
+				if(q->code)
+					parent->set_quot_xt(q,visitor(q->code));
+				break;
+			}
+		case CALLSTACK_TYPE:
+			{
+				callstack *stack = (callstack *)obj;
+				call_frame_code_block_visitor<Visitor> call_frame_visitor(parent,visitor);
+				parent->iterate_callstack_object(stack,call_frame_visitor);
+				break;
+			}
+		}
 	}
 
+	void visit_context_code_blocks()
+	{
+		call_frame_code_block_visitor<Visitor> call_frame_visitor(parent,visitor);
+		parent->iterate_active_frames(call_frame_visitor);
+	}
+
+	void visit_callback_code_blocks()
+	{
+		callback_code_block_visitor<Visitor> callback_visitor(parent->callbacks,visitor);
+		parent->callbacks->iterate(callback_visitor);
+	}
+
+};
+
 }

vm/compaction.cpp

@@ -29,11 +29,11 @@ struct code_block_forwarder {
 struct object_compaction_updater {
 	factor_vm *parent;
 	slot_visitor<object_slot_forwarder> slot_forwarder;
-	code_block_forwarder code_forwarder;
+	code_block_visitor<code_block_forwarder> code_forwarder;
 
 	explicit object_compaction_updater(factor_vm *parent_,
 		slot_visitor<object_slot_forwarder> slot_forwader_,
-		code_block_forwarder code_forwarder_) :
+		code_block_visitor<code_block_forwarder> code_forwarder_) :
 		parent(parent_),
 		slot_forwarder(slot_forwader_),
 		code_forwarder(code_forwarder_) {}
@@ -41,7 +41,7 @@ struct object_compaction_updater {
 	void operator()(object *obj, cell size)
 	{
 		slot_forwarder.visit_slots(obj);
-		parent->visit_object_code_block(obj,code_forwarder);
+		code_forwarder.visit_object_code_block(obj);
 	}
 };
 
@@ -71,14 +71,14 @@ void factor_vm::compact_full_impl(bool trace_contexts_p)
 
 	/* Update root pointers */
 	slot_visitor<object_slot_forwarder> slot_forwarder(this,object_slot_forwarder(data_forwarding_map));
-	code_block_forwarder code_forwarder(code_forwarding_map);
+	code_block_visitor<code_block_forwarder> code_forwarder(this,code_block_forwarder(code_forwarding_map));
 
 	slot_forwarder.visit_roots();
 	if(trace_contexts_p)
 	{
 		slot_forwarder.visit_contexts();
-		visit_context_code_blocks(code_forwarder);
+		code_forwarder.visit_context_code_blocks();
-		visit_callback_code_blocks(code_forwarder);
+		code_forwarder.visit_callback_code_blocks();
 	}
 
 	/* Slide everything in tenured space up, and update data and code heap

vm/full_collector.cpp

@@ -29,20 +29,6 @@ struct code_block_marker {
 	}
 };
 
-void full_collector::mark_reachable_objects()
-{
-	code_block_marker marker(code,this);
-	std::vector<object *> *mark_stack = &this->target->mark_stack;
-
-	while(!mark_stack->empty())
-	{
-		object *obj = mark_stack->back();
-		mark_stack->pop_back();
-		this->trace_slots(obj);
-		parent->visit_object_code_block(obj,marker);
-	}
-}
-
 struct object_start_map_updater {
 	object_start_map *starts;
 
@@ -62,16 +48,25 @@ void factor_vm::collect_full_impl(bool trace_contexts_p)
 	data->tenured->clear_mark_bits();
 	data->tenured->clear_mark_stack();
 
+	code_block_visitor<code_block_marker> code_marker(this,code_block_marker(code,&collector));
+
 	collector.trace_roots();
         if(trace_contexts_p)
 	{
 		collector.trace_contexts();
-		code_block_marker marker(code,&collector);
+		code_marker.visit_context_code_blocks();
-		visit_context_code_blocks(marker);
+		code_marker.visit_callback_code_blocks();
-		visit_callback_code_blocks(marker);
 	}
 
-	collector.mark_reachable_objects();
+	std::vector<object *> *mark_stack = &data->tenured->mark_stack;
+
+	while(!mark_stack->empty())
+	{
+		object *obj = mark_stack->back();
+		mark_stack->pop_back();
+		collector.trace_slots(obj);
+		code_marker.visit_object_code_block(obj);
+	}
 
 	data->tenured->starts.clear_object_start_offsets();
 	object_start_map_updater updater(&data->tenured->starts);

vm/full_collector.hpp

@@ -28,7 +28,6 @@ struct full_collector : collector<tenured_space,full_policy> {
 	bool trace_contexts_p;
 
 	full_collector(factor_vm *parent_);
-	void mark_reachable_objects();
 };
 
 }

vm/vm.hpp

@@ -485,11 +485,6 @@ struct factor_vm
 	code_block *allot_code_block(cell size, code_block_type type);
 	code_block *add_code_block(code_block_type type, cell code_, cell labels_, cell owner_, cell relocation_, cell literals_);
 
-	//code_block_visitor
-	template<typename Visitor> void visit_object_code_block(object *obj, Visitor visitor);
-	template<typename Visitor> void visit_context_code_blocks(Visitor visitor);
-	template<typename Visitor> void visit_callback_code_blocks(Visitor visitor);
-
 	//code heap
 	inline void check_code_pointer(cell ptr)
 	{