VM: refactor tagged.hpp so it's not dependent on the factor_vm class

this way untag<byte_array>(relocation) can be used in code_blocks.hpp

vm/alien.cpp

@@ -32,7 +32,7 @@ cell factor_vm::allot_alien(cell delegate_, cell displacement) {
   data_root<object> delegate(delegate_, this);
   data_root<alien> new_alien(allot<alien>(sizeof(alien)), this);
 
-  if (delegate.type_p(ALIEN_TYPE)) {
+  if (TAG(delegate_) == ALIEN_TYPE) {
     tagged<alien> delegate_alien = delegate.as<alien>();
     displacement += delegate_alien->displacement;
     new_alien->base = delegate_alien->base;
@@ -99,7 +99,7 @@ EACH_ALIEN_PRIMITIVE(DEFINE_ALIEN_ACCESSOR)
 /* Allocates memory */
 void factor_vm::primitive_dlopen() {
   data_root<byte_array> path(ctx->pop(), this);
-  path.untag_check(this);
+  check_tagged(path);
   data_root<dll> library(allot<dll>(sizeof(dll)), this);
   library->path = path.value();
   ffi_dlopen(library.untagged());
@@ -111,7 +111,7 @@ void factor_vm::primitive_dlopen() {
 void factor_vm::primitive_dlsym() {
   data_root<object> library(ctx->pop(), this);
   data_root<byte_array> name(ctx->peek(), this);
-  name.untag_check(this);
+  check_tagged(name);
 
   symbol_char* sym = name->data<symbol_char>();
 
@@ -131,7 +131,7 @@ void factor_vm::primitive_dlsym() {
 void factor_vm::primitive_dlsym_raw() {
   data_root<object> library(ctx->pop(), this);
   data_root<byte_array> name(ctx->peek(), this);
-  name.untag_check(this);
+  check_tagged(name);
 
   symbol_char* sym = name->data<symbol_char>();
 

vm/arrays.cpp

@@ -35,7 +35,7 @@ cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) {
 /* Allocates memory */
 void factor_vm::primitive_resize_array() {
   data_root<array> a(ctx->pop(), this);
-  a.untag_check(this);
+  check_tagged(a);
   cell capacity = unbox_array_size();
   ctx->push(tag<array>(reallot_array(a.untagged(), capacity)));
 }

vm/byte_arrays.cpp

@@ -24,7 +24,7 @@ void factor_vm::primitive_uninitialized_byte_array() {
 /* Allocates memory */
 void factor_vm::primitive_resize_byte_array() {
   data_root<byte_array> array(ctx->pop(), this);
-  array.untag_check(this);
+  check_tagged(array);
   cell capacity = unbox_array_size();
   ctx->push(tag<byte_array>(reallot_array(array.untagged(), capacity)));
 }

vm/callbacks.cpp

@@ -47,7 +47,7 @@ void callback_heap::store_callback_operand(code_block* stub, cell index,
 }
 
 void callback_heap::update(code_block* stub) {
-  word* w = (word*)UNTAG(stub->owner);
+  word* w = untag<word>(stub->owner);
   store_callback_operand(stub, 1, w->entry_point);
   stub->flush_icache();
 }
@@ -92,8 +92,7 @@ code_block* callback_heap::add(cell owner, cell return_rewind) {
 void factor_vm::primitive_callback() {
   cell return_rewind = to_cell(ctx->pop());
   tagged<word> w(ctx->pop());
-
-  w.untag_check(this);
+  check_tagged(w);
 
   cell func = callbacks->add(w.value(), return_rewind)->entry_point();
   CODE_TO_FUNCTION_POINTER_CALLBACK(this, func);

vm/callstack.cpp

@@ -100,8 +100,8 @@ void factor_vm::primitive_set_innermost_stack_frame_quotation() {
   data_root<callstack> stack(ctx->pop(), this);
   data_root<quotation> quot(ctx->pop(), this);
 
-  stack.untag_check(this);
-  quot.untag_check(this);
+  check_tagged(stack);
+  check_tagged(quot);
 
   jit_compile_quotation(quot.value(), true);
 

vm/callstack.hpp

@@ -5,7 +5,7 @@ inline static cell callstack_object_size(cell size) {
 }
 
 /* This is a little tricky. The iterator may allocate memory, so we
-keep the callstack in a GC root and use relative offsets */
+   keep the callstack in a GC root and use relative offsets */
 /* Allocates memory */
 template <typename Iterator, typename Fixup>
 inline void factor_vm::iterate_callstack_object(callstack* stack_,

vm/code_blocks.hpp

@@ -79,7 +79,7 @@ struct code_block {
     if (!to_boolean(relocation))
       return;
 
-    byte_array* rels = (byte_array*)UNTAG(relocation);
+    byte_array* rels = untag<byte_array>(relocation);
 
     cell index = 0;
     cell length = (rels->capacity >> TAG_BITS) / sizeof(relocation_entry);

vm/cpu-x86.cpp

@@ -69,8 +69,8 @@ void factor_vm::dispatch_resumable_signal(cell* sp, cell* pc, cell handler) {
   cell new_sp = *sp - delta;
   *sp = new_sp;
   *(cell*)new_sp = *pc;
-  tagged<word> handler_word = tagged<word>(special_objects[index]);
-  *pc = (cell)handler_word->entry_point;
+
+  *pc = untag<word>(special_objects[index])->entry_point;
 }
 
 void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {

vm/io.cpp

@@ -162,8 +162,8 @@ void factor_vm::safe_fflush(FILE* stream) {
 void factor_vm::primitive_fopen() {
   data_root<byte_array> mode(ctx->pop(), this);
   data_root<byte_array> path(ctx->pop(), this);
-  mode.untag_check(this);
-  path.untag_check(this);
+  check_tagged(mode);
+  check_tagged(path);
 
   FILE* file;
   file = safe_fopen((char*)(path.untagged() + 1),

vm/master.hpp

@@ -103,6 +103,7 @@ namespace factor { struct factor_vm; }
 #include "bignum.hpp"
 #include "booleans.hpp"
 #include "instruction_operands.hpp"
+#include "tagged.hpp"
 #include "code_blocks.hpp"
 #include "bump_allocator.hpp"
 #include "bitwise_hacks.hpp"
@@ -125,7 +126,6 @@ namespace factor { struct factor_vm; }
 #include "safepoints.hpp"
 #include "vm.hpp"
 #include "allot.hpp"
-#include "tagged.hpp"
 #include "data_roots.hpp"
 #include "code_roots.hpp"
 #include "generic_arrays.hpp"

vm/strings.cpp

@@ -100,7 +100,7 @@ string* factor_vm::reallot_string(string* str_, cell capacity) {
 /* Allocates memory */
 void factor_vm::primitive_resize_string() {
   data_root<string> str(ctx->pop(), this);
-  str.untag_check(this);
+  check_tagged(str);
   cell capacity = unbox_array_size();
   ctx->push(tag<string>(reallot_string(str.untagged(), capacity)));
 }

vm/tagged.hpp

@@ -13,13 +13,10 @@ template <typename Type> struct tagged {
 
   cell type() const { return TAG(value_); }
 
-  bool type_p(cell type_) const { return type() == type_; }
-
   bool type_p() const {
     if (Type::type_number == TYPE_COUNT)
       return true;
-    else
-      return type_p(Type::type_number);
+    return type() == Type::type_number;
   }
 
   cell value() const {
@@ -32,12 +29,6 @@ template <typename Type> struct tagged {
     return (Type*)(UNTAG(value_));
   }
 
-  Type* untag_check(factor_vm* parent) const {
-    if (!type_p())
-      parent->type_error(Type::type_number, value_);
-    return untagged();
-  }
-
   explicit tagged(cell tagged) : value_(tagged) {}
   explicit tagged(Type* untagged) : value_(factor::tag(untagged)) {}
 
@@ -61,10 +52,6 @@ template <typename Type> struct tagged {
   }
 };
 
-template <typename Type> Type* factor_vm::untag_check(cell value) {
-  return tagged<Type>(value).untag_check(this);
-}
-
 template <typename Type> Type* untag(cell value) {
   return tagged<Type>(value).untagged();
 }

vm/vm.hpp

@@ -537,7 +537,16 @@ struct factor_vm {
   inline double fixnum_to_float(cell tagged);
 
   // tagged
-  template <typename Type> Type* untag_check(cell value);
+  template <typename Type> void check_tagged(tagged<Type> t) {
+    if (!t.type_p())
+      type_error(Type::type_number, t.value());
+  }
+
+  template <typename Type> Type* untag_check(cell value) {
+    tagged<Type> t(value);
+    check_tagged(t);
+    return t.untagged();
+  }
 
   // io
   void init_c_io();

vm/words.cpp

@@ -75,7 +75,7 @@ void factor_vm::primitive_word() {
 /* Allocates memory (from_unsigned_cell allocates) */
 void factor_vm::primitive_word_code() {
   data_root<word> w(ctx->pop(), this);
-  w.untag_check(this);
+  check_tagged(w);
 
   ctx->push(from_unsigned_cell(w->entry_point));
   ctx->push(from_unsigned_cell((cell)w->code() + w->code()->size()));