diff --git a/vm/collector.hpp b/vm/collector.hpp
index 86ae963774..e0ff53df9b 100644
--- a/vm/collector.hpp
+++ b/vm/collector.hpp
@@ -209,7 +209,7 @@ template<typename TargetGeneration, typename Policy> struct collector {
 						if(end < card_start_address(card_index))
 						{
 							start = gen->starts.find_object_containing_card(card_index - gen_start_card);
-							binary_start = start + parent->binary_payload_start((object *)start);
+							binary_start = start + ((object *)start)->binary_payload_start();
 							end = start + ((object *)start)->size();
 						}
 	
@@ -229,7 +229,7 @@ scan_next_object:				{
 								start = gen->next_object_after(start);
 								if(start)
 								{
-									binary_start = start + parent->binary_payload_start((object *)start);
+									binary_start = ((object *)start)->binary_payload_start();
 									end = start + ((object *)start)->size();
 									goto scan_next_object;
 								}
diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp
index 6178dc8861..b210adb8e1 100755
--- a/vm/data_heap.cpp
+++ b/vm/data_heap.cpp
@@ -159,17 +159,12 @@ cell object::size() const
 	}
 }
 
-void factor_vm::primitive_size()
-{
-	box_unsigned_cell(object_size(dpop()));
-}
-
 /* The number of cells from the start of the object which should be scanned by
 the GC. Some types have a binary payload at the end (string, word, DLL) which
 we ignore. */
-cell factor_vm::binary_payload_start(object *pointer)
+cell object::binary_payload_start() const
 {
-	switch(pointer->h.hi_tag())
+	switch(h.hi_tag())
 	{
 	/* these objects do not refer to other objects at all */
 	case FLOAT_TYPE:
@@ -190,17 +185,22 @@ cell factor_vm::binary_payload_start(object *pointer)
 		return sizeof(string);
 	/* everything else consists entirely of pointers */
 	case ARRAY_TYPE:
-		return array_size<array>(array_capacity((array*)pointer));
+		return array_size<array>(array_capacity((array*)this));
 	case TUPLE_TYPE:
-		return tuple_size(untag<tuple_layout>(((tuple *)pointer)->layout));
+		return tuple_size(untag<tuple_layout>(((tuple *)this)->layout));
 	case WRAPPER_TYPE:
 		return sizeof(wrapper);
 	default:
-		critical_error("Invalid header",(cell)pointer);
+		critical_error("Invalid header",(cell)this);
                 return 0; /* can't happen */
 	}
 }
 
+void factor_vm::primitive_size()
+{
+	box_unsigned_cell(object_size(dpop()));
+}
+
 /* Push memory usage statistics in data heap */
 void factor_vm::primitive_data_room()
 {
diff --git a/vm/generic_arrays.hpp b/vm/generic_arrays.hpp
index e1d2c4dc0b..89eb56a70d 100755
--- a/vm/generic_arrays.hpp
+++ b/vm/generic_arrays.hpp
@@ -1,7 +1,7 @@
 namespace factor
 {
 
-template<typename Array> cell array_capacity(Array *array)
+template<typename Array> cell array_capacity(const Array *array)
 {
 #ifdef FACTOR_DEBUG
 	assert(array->h.hi_tag() == Array::type_number);
diff --git a/vm/layouts.hpp b/vm/layouts.hpp
index c90be1b2dd..b3cba58495 100644
--- a/vm/layouts.hpp
+++ b/vm/layouts.hpp
@@ -148,6 +148,7 @@ struct object {
 	header h;
 
 	cell size() const;
+	cell binary_payload_start() const;
 
 	cell *slots()  const { return (cell *)this; }
 
diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp
index 6e0f6839e2..67a51549b1 100644
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -22,7 +22,7 @@ template<typename Visitor> struct slot_visitor {
 	void visit_slots(object *ptr)
 	{
 		cell *slot = (cell *)ptr;
-		cell *end = (cell *)((cell)ptr + parent->binary_payload_start(ptr));
+		cell *end = (cell *)((cell)ptr + ptr->binary_payload_start());
 
 		if(slot != end)
 		{
diff --git a/vm/tuples.hpp b/vm/tuples.hpp
index 04b23b5857..bcd041fc65 100644
--- a/vm/tuples.hpp
+++ b/vm/tuples.hpp
@@ -1,7 +1,7 @@
 namespace factor
 {
 
-inline static cell tuple_size(tuple_layout *layout)
+inline static cell tuple_size(const tuple_layout *layout)
 {
 	cell size = untag_fixnum(layout->size);
 	return sizeof(tuple) + size * sizeof(cell);
diff --git a/vm/vm.hpp b/vm/vm.hpp
index b596b7a50c..0b66025374 100755
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -223,7 +223,6 @@ struct factor_vm
 	void set_data_heap(data_heap *data_);
 	void init_data_heap(cell young_size, cell aging_size, cell tenured_size);
 	void primitive_size();
-	cell binary_payload_start(object *pointer);
 	void primitive_data_room();
 	void begin_scan();
 	void end_scan();
@@ -576,7 +575,7 @@ struct factor_vm
 	template<typename Iterator> void do_slots(cell obj, Iterator &iter)
 	{
 		cell scan = obj;
-		cell payload_start = binary_payload_start((object *)obj);
+		cell payload_start = ((object *)obj)->binary_payload_start();
 		cell end = obj + payload_start;
 
 		scan += sizeof(cell);