From 22bb0cfecfc5c09953b613e3ad01d2a713585ea7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Lindqvist?= Date: Mon, 23 Nov 2015 02:27:22 +0100 Subject: [PATCH] VM: fixes to use the TAG macro over tagged(obj).type() --- vm/alien.cpp | 6 +++--- vm/code_blocks.cpp | 43 +++++++++++++++++++------------------------ vm/code_blocks.hpp | 19 ++++++++++--------- vm/debug.cpp | 8 ++++---- vm/dispatch.cpp | 2 +- vm/objects.cpp | 9 ++++----- 6 files changed, 41 insertions(+), 46 deletions(-) diff --git a/vm/alien.cpp b/vm/alien.cpp index 9768908f2f..7fe30bb69d 100644 --- a/vm/alien.cpp +++ b/vm/alien.cpp @@ -5,7 +5,7 @@ namespace factor { /* gets the address of an object representing a C pointer, with the intention of storing the pointer across code which may potentially GC. */ char* factor_vm::pinned_alien_offset(cell obj) { - switch (tagged(obj).type()) { + switch (TAG(obj)) { case ALIEN_TYPE: { alien* ptr = untag(obj); if (to_boolean(ptr->expired)) @@ -57,7 +57,7 @@ void factor_vm::primitive_displaced_alien() { cell alien = ctx->pop(); cell displacement = to_cell(ctx->pop()); - switch (tagged(alien).type()) { + switch (TAG(alien)) { case BYTE_ARRAY_TYPE: case ALIEN_TYPE: case F_TYPE: @@ -163,7 +163,7 @@ void factor_vm::primitive_dll_validp() { /* gets the address of an object representing a C pointer */ char* factor_vm::alien_offset(cell obj) { - switch (tagged(obj).type()) { + switch (TAG(obj)) { case BYTE_ARRAY_TYPE: return untag(obj)->data(); case ALIEN_TYPE: diff --git a/vm/code_blocks.cpp b/vm/code_blocks.cpp index 0eb1ed338f..f65af3d9ed 100644 --- a/vm/code_blocks.cpp +++ b/vm/code_blocks.cpp @@ -3,10 +3,9 @@ namespace factor { cell code_block::owner_quot() const { - tagged executing(owner); - if (!optimized_p() && executing->type() == WORD_TYPE) - executing = executing.as()->def; - return executing.value(); + if (!optimized_p() && TAG(owner) == WORD_TYPE) + return untag(owner)->def; + return owner; } /* If the code block is an unoptimized quotation, we can calculate the @@ -16,18 +15,17 @@ cell code_block::scan(factor_vm* vm, cell addr) const { return tag_fixnum(-1); } - tagged obj(owner); - if (obj.type_p(WORD_TYPE)) - obj = obj.as()->def; - if (!obj.type_p(QUOTATION_TYPE)) + cell ptr = owner; + if (TAG(ptr) == WORD_TYPE) + ptr = untag(ptr)->def; + if (TAG(ptr) != QUOTATION_TYPE) return tag_fixnum(-1); - cell ofs = offset(addr); - return tag_fixnum(vm->quot_code_offset_to_scan(obj.value(), ofs)); + return tag_fixnum(vm->quot_code_offset_to_scan(ptr, ofs)); } cell factor_vm::compute_entry_point_address(cell obj) { - switch (tagged(obj).type()) { + switch (TAG(obj)) { case WORD_TYPE: return untag(obj)->entry_point; case QUOTATION_TYPE: @@ -58,24 +56,21 @@ cell factor_vm::compute_entry_point_pic_tail_address(cell w_) { } cell factor_vm::code_block_owner(code_block* compiled) { - tagged owner(compiled->owner); + cell owner = compiled->owner; /* Cold generic word call sites point to quotations that call the inline-cache-miss and inline-cache-miss-tail primitives. */ - if (owner.type_p(QUOTATION_TYPE)) { - tagged quot(owner.as()); - tagged elements(quot->array); + if (TAG(owner) != QUOTATION_TYPE) + return owner; - FACTOR_ASSERT(array_capacity(elements.untagged()) == 5); - FACTOR_ASSERT(array_nth(elements.untagged(), 4) == - special_objects[PIC_MISS_WORD] || - array_nth(elements.untagged(), 4) == - special_objects[PIC_MISS_TAIL_WORD]); + quotation* quot = untag(owner); + array* elements = untag(quot->array); - tagged word_wrapper(array_nth(elements.untagged(), 0)); - return word_wrapper->object; - } else - return compiled->owner; + FACTOR_ASSERT(array_capacity(elements) == 5); + FACTOR_ASSERT(array_nth(elements, 4) == special_objects[PIC_MISS_WORD] || + array_nth(elements, 4) == special_objects[PIC_MISS_TAIL_WORD]); + wrapper* wrap = untag(array_nth(elements, 0)); + return wrap->object; } struct update_word_references_relocation_visitor { diff --git a/vm/code_blocks.hpp b/vm/code_blocks.hpp index bfff763eea..00c97985a8 100644 --- a/vm/code_blocks.hpp +++ b/vm/code_blocks.hpp @@ -76,17 +76,18 @@ struct code_block { void flush_icache() { factor::flush_icache((cell)this, size()); } template void each_instruction_operand(Iterator& iter) { - if (to_boolean(relocation)) { - byte_array* rels = (byte_array*)UNTAG(relocation); + if (!to_boolean(relocation)) + return; - cell index = 0; - cell length = (rels->capacity >> TAG_BITS) / sizeof(relocation_entry); + byte_array* rels = (byte_array*)UNTAG(relocation); - for (cell i = 0; i < length; i++) { - relocation_entry rel = rels->data()[i]; - iter(instruction_operand(rel, this, index)); - index += rel.number_of_parameters(); - } + cell index = 0; + cell length = (rels->capacity >> TAG_BITS) / sizeof(relocation_entry); + + for (cell i = 0; i < length; i++) { + relocation_entry rel = rels->data()[i]; + iter(instruction_operand(rel, this, index)); + index += rel.number_of_parameters(); } } diff --git a/vm/debug.cpp b/vm/debug.cpp index a464ff751b..762aa524b1 100644 --- a/vm/debug.cpp +++ b/vm/debug.cpp @@ -13,10 +13,10 @@ ostream& operator<<(ostream& out, const string* str) { } void factor_vm::print_word(ostream& out, word* word, cell nesting) { - if (tagged(word->vocabulary).type_p(STRING_TYPE)) + if (TAG(word->vocabulary) == STRING_TYPE) out << untag(word->vocabulary) << ":"; - if (tagged(word->name).type_p(STRING_TYPE)) + if (TAG(word->name) == STRING_TYPE) out << untag(word->name); else { out << "#(obj).type()) { + switch (TAG(obj)) { case FIXNUM_TYPE: out << untag_fixnum(obj); break; @@ -158,7 +158,7 @@ void factor_vm::print_nested_obj(ostream& out, cell obj, fixnum nesting) { print_alien(out, untag(obj), nesting - 1); break; default: - out << "#<" << type_name(tagged(obj).type()) << " @ "; + out << "#<" << type_name(TAG(obj)) << " @ "; out << (void*)obj << ">"; break; } diff --git a/vm/dispatch.cpp b/vm/dispatch.cpp index 1c522bfb68..0fe653489a 100644 --- a/vm/dispatch.cpp +++ b/vm/dispatch.cpp @@ -45,7 +45,7 @@ cell factor_vm::lookup_tuple_method(cell obj, cell methods) { while (echelon >= 0) { cell echelon_methods = array_nth(echelons, echelon); - if (tagged(echelon_methods).type_p(WORD_TYPE)) + if (TAG(echelon_methods) == WORD_TYPE) return echelon_methods; else if (to_boolean(echelon_methods)) { cell klass = nth_superclass(layout, echelon); diff --git a/vm/objects.cpp b/vm/objects.cpp index 034f3ada2a..e0ea7d8e33 100644 --- a/vm/objects.cpp +++ b/vm/objects.cpp @@ -102,11 +102,10 @@ void factor_vm::primitive_become() { std::map become_map; for (cell i = 0; i < capacity; i++) { - tagged old_obj(array_nth(old_objects, i)); - tagged new_obj(array_nth(new_objects, i)); - - if (old_obj != new_obj) - become_map[old_obj.untagged()] = new_obj.untagged(); + cell old_ptr = array_nth(old_objects, i); + cell new_ptr = array_nth(new_objects, i); + if (old_ptr != new_ptr) + become_map[untag(old_ptr)] = untag(new_ptr); } /* Update all references to old objects to point to new objects */