vm: strip out call-counting profiler

[factor.git] / vm / code_block_visitor.hpp

diff --git a/vm/code_block_visitor.hpp b/vm/code_block_visitor.hpp
index dce82843f810a434114428e64d16933ce1d98411..2421ace669657b6565939e9d0c31181dc880807e 100644 (file)
--- a/vm/code_block_visitor.hpp
+++ b/vm/code_block_visitor.hpp
@@ -12,111 +12,109 @@ Iteration is driven by visit_*() methods. Some of them define GC roots:
 - visit_context_code_blocks()
 - visit_callback_code_blocks() */
  
-template<typename Visitor> struct code_block_visitor {
+template<typename Fixup> struct code_block_visitor {
        factor_vm *parent;
-       Visitor visitor;
+       Fixup fixup;
 
-       explicit code_block_visitor(factor_vm *parent_, Visitor visitor_) :
-               parent(parent_), visitor(visitor_) {}
+       explicit code_block_visitor(factor_vm *parent_, Fixup fixup_) :
+               parent(parent_), fixup(fixup_) {}
 
        code_block *visit_code_block(code_block *compiled);
        void visit_object_code_block(object *obj);
        void visit_embedded_code_pointers(code_block *compiled);
        void visit_context_code_blocks();
        void visit_uninitialized_code_blocks();
+
+       void visit_code_roots();
 };
 
-template<typename Visitor>
-code_block *code_block_visitor<Visitor>::visit_code_block(code_block *compiled)
+template<typename Fixup>
+code_block *code_block_visitor<Fixup>::visit_code_block(code_block *compiled)
 {
-       return visitor(compiled);
+       return fixup.fixup_code(compiled);
 }
 
-template<typename Visitor>
+template<typename Fixup>
 struct call_frame_code_block_visitor {
        factor_vm *parent;
-       Visitor visitor;
+       Fixup fixup;
 
-       explicit call_frame_code_block_visitor(factor_vm *parent_, Visitor visitor_) :
-               parent(parent_), visitor(visitor_) {}
+       explicit call_frame_code_block_visitor(factor_vm *parent_, Fixup fixup_) :
+               parent(parent_), fixup(fixup_) {}
 
        void operator()(stack_frame *frame)
        {
-               cell offset = (cell)FRAME_RETURN_ADDRESS(frame,parent) - (cell)frame->xt;
-
-               code_block *new_block = visitor(parent->frame_code(frame));
-               frame->xt = new_block->xt();
-
-               FRAME_RETURN_ADDRESS(frame,parent) = (void *)((cell)frame->xt + offset);
+               cell offset = parent->frame_offset(frame);
+               code_block *compiled = fixup.fixup_code(parent->frame_code(frame));
+               frame->entry_point = compiled->entry_point();
+               parent->set_frame_offset(frame,offset);
        }
 };
 
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_object_code_block(object *obj)
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_object_code_block(object *obj)
 {
        switch(obj->type())
        {
        case WORD_TYPE:
                {
                        word *w = (word *)obj;
-                       if(w->code)
-                               w->code = visitor(w->code);
-                       if(w->profiling)
-                               w->profiling = visitor(w->profiling);
-
-                       parent->update_word_xt(w);
+                       if(w->entry_point)
+                               w->entry_point = visit_code_block(w->code())->entry_point();
                        break;
                }
        case QUOTATION_TYPE:
                {
                        quotation *q = (quotation *)obj;
-                       if(q->code)
-                               parent->set_quot_xt(q,visitor(q->code));
+                       if(q->entry_point)
+                               q->entry_point = visit_code_block(q->code())->entry_point();
                        break;
                }
        case CALLSTACK_TYPE:
                {
                        callstack *stack = (callstack *)obj;
-                       call_frame_code_block_visitor<Visitor> call_frame_visitor(parent,visitor);
+                       call_frame_code_block_visitor<Fixup> call_frame_visitor(parent,fixup);
                        parent->iterate_callstack_object(stack,call_frame_visitor);
                        break;
                }
        }
 }
 
-template<typename Visitor>
+template<typename Fixup>
 struct embedded_code_pointers_visitor {
-       Visitor visitor;
+       Fixup fixup;
 
-       explicit embedded_code_pointers_visitor(Visitor visitor_) : visitor(visitor_) {}
+       explicit embedded_code_pointers_visitor(Fixup fixup_) : fixup(fixup_) {}
 
        void operator()(instruction_operand op)
        {
                relocation_type type = op.rel_type();
-               if(type == RT_XT || type == RT_XT_PIC || type == RT_XT_PIC_TAIL)
-                       op.store_code_block(visitor(op.load_code_block()));
+               if(type == RT_ENTRY_POINT
+                       || type == RT_ENTRY_POINT_PIC
+                       || type == RT_ENTRY_POINT_PIC_TAIL)
+                       op.store_code_block(fixup.fixup_code(op.load_code_block()));
        }
 };
 
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_embedded_code_pointers(code_block *compiled)
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_embedded_code_pointers(code_block *compiled)
 {
        if(!parent->code->uninitialized_p(compiled))
        {
-               embedded_code_pointers_visitor<Visitor> visitor(this->visitor);
-               compiled->each_instruction_operand(visitor);
+               embedded_code_pointers_visitor<Fixup> operand_visitor(fixup);
+               compiled->each_instruction_operand(operand_visitor);
        }
 }
 
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_context_code_blocks()
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_context_code_blocks()
 {
-       call_frame_code_block_visitor<Visitor> call_frame_visitor(parent,visitor);
-       parent->iterate_active_frames(call_frame_visitor);
+       call_frame_code_block_visitor<Fixup> call_frame_visitor(parent,fixup);
+       parent->iterate_active_callstacks(call_frame_visitor);
 }
 
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_uninitialized_code_blocks()
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_uninitialized_code_blocks()
 {
        std::map<code_block *, cell> *uninitialized_blocks = &parent->code->uninitialized_blocks;
        std::map<code_block *, cell>::const_iterator iter = uninitialized_blocks->begin();
@@ -126,11 +124,17 @@ void code_block_visitor<Visitor>::visit_uninitialized_code_blocks()
        for(; iter != end; iter++)
        {
                new_uninitialized_blocks.insert(std::make_pair(
-                       visitor(iter->first),
+                       fixup.fixup_code(iter->first),
                        iter->second));
        }
 
        parent->code->uninitialized_blocks = new_uninitialized_blocks;
 }
 
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_code_roots()
+{
+       visit_uninitialized_code_blocks();
+}
+
 }