VM: some more fixing to make the types match better, converting void* to cell

vm/callstack.cpp

@@ -67,8 +67,7 @@ struct stack_frame_accumulator {
 
 
   /* Allocates memory (frames.add()) */
-  void operator()(void* frame_top, cell frame_size, code_block* owner,
+  void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
-                  void* addr) {
     data_root<object> executing_quot(owner->owner_quot(), parent);
     data_root<object> executing(owner->owner, parent);
     data_root<object> scan(owner->scan(parent, addr), parent);
@@ -113,7 +112,7 @@ void factor_vm::primitive_innermost_stack_frame_executing() {
 void factor_vm::primitive_innermost_stack_frame_scan() {
   callstack* stack = untag_check<callstack>(ctx->peek());
   void* frame = stack->top();
-  void* addr = *(void**)frame;
+  cell addr = *(cell*)frame;
   ctx->replace(code->code_block_for_address((cell)addr)->scan(this, addr));
 }
 

vm/callstack.hpp

@@ -16,14 +16,14 @@ inline void factor_vm::iterate_callstack_object(callstack* stack_,
   fixnum frame_offset = 0;
 
   while (frame_offset < frame_length) {
-    void* frame_top = stack->frame_top_at(frame_offset);
+    cell frame_top = (cell)stack->frame_top_at(frame_offset);
-    void* addr = *(void**)frame_top;
+    cell addr = *(cell*)frame_top;
+    cell fixed_addr = Fixup::translated_code_block_map
+                          ? (cell)fixup.translate_code((code_block*)addr)
+                          : addr;
+    code_block* owner = code->code_block_for_address(fixed_addr);
 
-    void* fixed_addr = Fixup::translated_code_block_map
+    cell frame_size = owner->stack_frame_size_for_address(fixed_addr);
-                           ? (void*)fixup.translate_code((code_block*)addr)
-                           : addr;
-    code_block* owner = code->code_block_for_address((cell)fixed_addr);
-    cell frame_size = owner->stack_frame_size_for_address((cell)fixed_addr);
 
     iterator(frame_top, frame_size, owner, fixed_addr);
     frame_offset += frame_size;
@@ -46,23 +46,22 @@ inline void factor_vm::iterate_callstack(context* ctx, Iterator& iterator,
   cell frame_top = ctx->callstack_top;
 
   while (frame_top < ctx->callstack_bottom) {
-    void* addr = *(void**)frame_top;
+    cell addr = *(cell*)frame_top;
     FACTOR_ASSERT(addr != 0);
-    void* fixed_addr = Fixup::translated_code_block_map
+    cell fixed_addr = Fixup::translated_code_block_map
-                           ? (void*)fixup.translate_code((code_block*)addr)
+                          ? (cell)fixup.translate_code((code_block*)addr)
-                           : addr;
+                          : addr;
 
-    code_block* owner = code->code_block_for_address((cell)fixed_addr);
+    code_block* owner = code->code_block_for_address(fixed_addr);
     code_block* fixed_owner =
         Fixup::translated_code_block_map ? owner : fixup.translate_code(owner);
 
-    cell frame_size =
+    cell frame_size = fixed_owner->stack_frame_size_for_address(fixed_addr);
-        fixed_owner->stack_frame_size_for_address((cell)fixed_addr);
 
-    void* fixed_addr_for_iter =
+    cell fixed_addr_for_iter =
         Fixup::translated_code_block_map ? fixed_addr : addr;
 
-    iterator((void*)frame_top, frame_size, owner, fixed_addr_for_iter);
+    iterator(frame_top, frame_size, owner, fixed_addr_for_iter);
     frame_top += frame_size;
   }
 }

vm/code_block_visitor.hpp

@@ -39,13 +39,12 @@ template <typename Fixup> struct call_frame_code_block_visitor {
   call_frame_code_block_visitor(factor_vm* parent, Fixup fixup)
       : parent(parent), fixup(fixup) {}
 
-  void operator()(void* frame_top, cell frame_size, code_block* owner,
+  void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
-                  void* addr) {
     code_block* compiled =
         Fixup::translated_code_block_map ? owner : fixup.fixup_code(owner);
-    void* fixed_addr = compiled->address_for_offset(owner->offset(addr));
+    cell fixed_addr = compiled->address_for_offset(owner->offset((void*)addr));
 
-    *(void**)frame_top = fixed_addr;
+    *(cell*)frame_top = fixed_addr;
   }
 };
 

vm/code_blocks.cpp

@@ -11,7 +11,7 @@ cell code_block::owner_quot() const {
 
 /* If the code block is an unoptimized quotation, we can calculate the
    scan offset. In all other cases -1 is returned. */
-cell code_block::scan(factor_vm* vm, void* addr) const {
+cell code_block::scan(factor_vm* vm, cell addr) const {
   if (type() != code_block_unoptimized) {
     return tag_fixnum(-1);
   }
@@ -22,7 +22,7 @@ cell code_block::scan(factor_vm* vm, void* addr) const {
   if (!obj.type_p(QUOTATION_TYPE))
     return tag_fixnum(-1);
 
-  cell ofs = offset(addr);
+  cell ofs = offset((void*)addr);
   return tag_fixnum(vm->quot_code_offset_to_scan(obj.value(), ofs));
 }
 

vm/code_blocks.hpp

@@ -94,11 +94,11 @@ struct code_block {
 
   cell offset(void* addr) const { return (char*)addr - (char*)entry_point(); }
 
-  void* address_for_offset(cell offset) const {
+  cell address_for_offset(cell offset) const {
-    return (void*)((char*)entry_point() + offset);
+    return (cell)((char*)entry_point() + offset);
   }
 
-  cell scan(factor_vm* vm, void* addr) const;
+  cell scan(factor_vm* vm, cell addr) const;
   cell owner_quot() const;
 };
 

vm/debug.cpp

@@ -190,10 +190,9 @@ struct stack_frame_printer {
   factor_vm* parent;
 
   explicit stack_frame_printer(factor_vm* parent) : parent(parent) {}
-  void operator()(void* frame_top, cell frame_size, code_block* owner,
+  void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
-                  void* addr) {
     std::cout << std::endl;
-    std::cout << "frame: " << frame_top << " size " << frame_size << std::endl;
+    std::cout << "frame: " << (void*)frame_top << " size " << size << std::endl;
     std::cout << "executing: ";
     parent->print_obj(owner->owner);
     std::cout << std::endl;
@@ -207,7 +206,7 @@ struct stack_frame_printer {
     std::cout << std::hex << (cell)owner->entry_point() << std::dec;
     std::cout << std::endl;
     std::cout << "return address: ";
-    std::cout << std::hex << (cell)addr << std::dec;
+    std::cout << std::hex << addr << std::dec;
     std::cout << std::endl;
   }
 };

vm/sampling_profiler.cpp

@@ -47,8 +47,7 @@ struct record_callstack_sample_iterator {
                                    bool prolog_p)
       : sample_callstacks(sample_callstacks), skip_p(prolog_p) {}
 
-  void operator()(void* frame_top, cell frame_size, code_block* owner,
+  void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
-                  void* addr) {
     if (skip_p)
       skip_p = false;
     else

vm/slot_visitor.hpp

@@ -294,9 +294,8 @@ template <typename Fixup> struct call_frame_slot_visitor {
 	             [entry_point]
 	             [size]
 	*/
-  void operator()(void* frame_top, cell frame_size, code_block* owner,
+  void operator()(cell frame_top, cell size, code_block* owner, cell addr) {
-                  void* addr) {
+    cell return_address = owner->offset((void*)addr);
-    cell return_address = owner->offset(addr);
 
     code_block* compiled =
         Fixup::translated_code_block_map ? owner