vm/objects.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 void factor_vm::primitive_special_object()
   7 {
   8         fixnum n = untag_fixnum(ctx->peek());
   9         ctx->replace(special_objects[n]);
  10 }
  11
  12 void factor_vm::primitive_set_special_object()
  13 {
  14         fixnum n = untag_fixnum(ctx->pop());
  15         cell value = ctx->pop();
  16         special_objects[n] = value;
  17 }
  18
  19 void factor_vm::primitive_identity_hashcode()
  20 {
  21         cell tagged = ctx->peek();
  22         object *obj = untag<object>(tagged);
  23         ctx->replace(tag_fixnum(obj->hashcode()));
  24 }
  25
  26 void factor_vm::compute_identity_hashcode(object *obj)
  27 {
  28         object_counter++;
  29         if(object_counter == 0) object_counter++;
  30         obj->set_hashcode((cell)obj ^ object_counter);
  31 }
  32
  33 void factor_vm::primitive_compute_identity_hashcode()
  34 {
  35         object *obj = untag<object>(ctx->pop());
  36         compute_identity_hashcode(obj);
  37 }
  38
  39 void factor_vm::primitive_set_slot()
  40 {
  41         fixnum slot = untag_fixnum(ctx->pop());
  42         object *obj = untag<object>(ctx->pop());
  43         cell value = ctx->pop();
  44
  45         cell *slot_ptr = &obj->slots()[slot];
  46         *slot_ptr = value;
  47         write_barrier(slot_ptr);
  48 }
  49
  50 cell factor_vm::clone_object(cell obj_)
  51 {
  52         data_root<object> obj(obj_,this);
  53
  54         if(immediate_p(obj.value()))
  55                 return obj.value();
  56         else
  57         {
  58                 cell size = object_size(obj.value());
  59                 object *new_obj = allot_object(obj.type(),size);
  60                 memcpy(new_obj,obj.untagged(),size);
  61                 new_obj->set_hashcode(0);
  62                 return tag_dynamic(new_obj);
  63         }
  64 }
  65
  66 void factor_vm::primitive_clone()
  67 {
  68         ctx->replace(clone_object(ctx->peek()));
  69 }
  70
  71 /* Size of the object pointed to by a tagged pointer */
  72 cell factor_vm::object_size(cell tagged)
  73 {
  74         if(immediate_p(tagged))
  75                 return 0;
  76         else
  77                 return untag<object>(tagged)->size();
  78 }
  79
  80 /* Allocates memory */
  81 void factor_vm::primitive_size()
  82 {
  83         ctx->push(from_unsigned_cell(object_size(ctx->pop())));
  84 }
  85
  86 struct slot_become_fixup : no_fixup {
  87         std::map<object *,object *> *become_map;
  88
  89         explicit slot_become_fixup(std::map<object *,object *> *become_map_) :
  90                 become_map(become_map_) {}
  91
  92         object *fixup_data(object *old)
  93         {
  94                 std::map<object *,object *>::const_iterator iter = become_map->find(old);
  95                 if(iter != become_map->end())
  96                         return iter->second;
  97                 else
  98                         return old;
  99         }
 100 };
 101
 102 struct object_become_visitor {
 103         slot_visitor<slot_become_fixup> *workhorse;
 104
 105         explicit object_become_visitor(slot_visitor<slot_become_fixup> *workhorse_) :
 106                 workhorse(workhorse_) {}
 107
 108         void operator()(object *obj)
 109         {
 110                 workhorse->visit_slots(obj);
 111         }
 112 };
 113
 114 struct code_block_become_visitor {
 115         slot_visitor<slot_become_fixup> *workhorse;
 116
 117         explicit code_block_become_visitor(slot_visitor<slot_become_fixup> *workhorse_) :
 118                 workhorse(workhorse_) {}
 119
 120         void operator()(code_block *compiled, cell size)
 121         {
 122                 workhorse->visit_code_block_objects(compiled);
 123                 workhorse->visit_embedded_literals(compiled);
 124         }
 125 };
 126
 127 struct code_block_write_barrier_visitor {
 128         code_heap *code;
 129
 130         explicit code_block_write_barrier_visitor(code_heap *code_) :
 131                 code(code_) {}
 132
 133         void operator()(code_block *compiled, cell size)
 134         {
 135                 code->write_barrier(compiled);
 136         }
 137 };
 138
 139 /* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this
 140    to coalesce equal but distinct quotations and wrappers. */
 141 void factor_vm::primitive_become()
 142 {
 143         array *new_objects = untag_check<array>(ctx->pop());
 144         array *old_objects = untag_check<array>(ctx->pop());
 145
 146         cell capacity = array_capacity(new_objects);
 147         if(capacity != array_capacity(old_objects))
 148                 critical_error("bad parameters to become",0);
 149
 150         /* Build the forwarding map */
 151         std::map<object *,object *> become_map;
 152
 153         for(cell i = 0; i < capacity; i++)
 154         {
 155                 tagged<object> old_obj(array_nth(old_objects,i));
 156                 tagged<object> new_obj(array_nth(new_objects,i));
 157
 158                 if(old_obj != new_obj)
 159                         become_map[old_obj.untagged()] = new_obj.untagged();
 160         }
 161
 162         /* Update all references to old objects to point to new objects */
 163         {
 164                 slot_visitor<slot_become_fixup> workhorse(this,slot_become_fixup(&become_map));
 165                 workhorse.visit_roots();
 166                 workhorse.visit_contexts();
 167
 168                 object_become_visitor object_visitor(&workhorse);
 169                 each_object(object_visitor);
 170
 171                 code_block_become_visitor code_block_visitor(&workhorse);
 172                 each_code_block(code_block_visitor);
 173         }
 174
 175         /* Since we may have introduced old->new references, need to revisit
 176         all objects and code blocks on a minor GC. */
 177         data->mark_all_cards();
 178
 179         {
 180                 code_block_write_barrier_visitor code_block_visitor(code);
 181                 each_code_block(code_block_visitor);
 182         }
 183 }
 184
 185 }