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 /* Allocates memory */
  51 cell factor_vm::clone_object(cell obj_)
  52 {
  53         data_root<object> obj(obj_,this);
  54
  55         if(immediate_p(obj.value()))
  56                 return obj.value();
  57         else
  58         {
  59                 cell size = object_size(obj.value());
  60                 object *new_obj = allot_object(obj.type(),size);
  61                 memcpy(new_obj,obj.untagged(),size);
  62                 new_obj->set_hashcode(0);
  63                 return tag_dynamic(new_obj);
  64         }
  65 }
  66
  67 /* Allocates memory */
  68 void factor_vm::primitive_clone()
  69 {
  70         ctx->replace(clone_object(ctx->peek()));
  71 }
  72
  73 /* Size of the object pointed to by a tagged pointer */
  74 cell factor_vm::object_size(cell tagged)
  75 {
  76         if(immediate_p(tagged))
  77                 return 0;
  78         else
  79                 return untag<object>(tagged)->size();
  80 }
  81
  82 /* Allocates memory */
  83 void factor_vm::primitive_size()
  84 {
  85         ctx->push(from_unsigned_cell(object_size(ctx->pop())));
  86 }
  87
  88 struct slot_become_fixup : no_fixup {
  89         std::map<object *,object *> *become_map;
  90
  91         explicit slot_become_fixup(std::map<object *,object *> *become_map_) :
  92                 become_map(become_map_) {}
  93
  94         object *fixup_data(object *old)
  95         {
  96                 std::map<object *,object *>::const_iterator iter = become_map->find(old);
  97                 if(iter != become_map->end())
  98                         return iter->second;
  99                 else
 100                         return old;
 101         }
 102 };
 103
 104 struct object_become_visitor {
 105         slot_visitor<slot_become_fixup> *workhorse;
 106
 107         explicit object_become_visitor(slot_visitor<slot_become_fixup> *workhorse_) :
 108                 workhorse(workhorse_) {}
 109
 110         void operator()(object *obj)
 111         {
 112                 workhorse->visit_slots(obj);
 113         }
 114 };
 115
 116 struct code_block_become_visitor {
 117         slot_visitor<slot_become_fixup> *workhorse;
 118
 119         explicit code_block_become_visitor(slot_visitor<slot_become_fixup> *workhorse_) :
 120                 workhorse(workhorse_) {}
 121
 122         void operator()(code_block *compiled, cell size)
 123         {
 124                 workhorse->visit_code_block_objects(compiled);
 125                 workhorse->visit_embedded_literals(compiled);
 126         }
 127 };
 128
 129 struct code_block_write_barrier_visitor {
 130         code_heap *code;
 131
 132         explicit code_block_write_barrier_visitor(code_heap *code_) :
 133                 code(code_) {}
 134
 135         void operator()(code_block *compiled, cell size)
 136         {
 137                 code->write_barrier(compiled);
 138         }
 139 };
 140
 141 /* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this
 142    to coalesce equal but distinct quotations and wrappers. */
 143 void factor_vm::primitive_become()
 144 {
 145         array *new_objects = untag_check<array>(ctx->pop());
 146         array *old_objects = untag_check<array>(ctx->pop());
 147
 148         cell capacity = array_capacity(new_objects);
 149         if(capacity != array_capacity(old_objects))
 150                 critical_error("bad parameters to become",0);
 151
 152         /* Build the forwarding map */
 153         std::map<object *,object *> become_map;
 154
 155         for(cell i = 0; i < capacity; i++)
 156         {
 157                 tagged<object> old_obj(array_nth(old_objects,i));
 158                 tagged<object> new_obj(array_nth(new_objects,i));
 159
 160                 if(old_obj != new_obj)
 161                         become_map[old_obj.untagged()] = new_obj.untagged();
 162         }
 163
 164         /* Update all references to old objects to point to new objects */
 165         {
 166                 slot_visitor<slot_become_fixup> workhorse(this,slot_become_fixup(&become_map));
 167                 workhorse.visit_roots();
 168                 workhorse.visit_contexts();
 169
 170                 object_become_visitor object_visitor(&workhorse);
 171                 each_object(object_visitor);
 172
 173                 code_block_become_visitor code_block_visitor(&workhorse);
 174                 each_code_block(code_block_visitor);
 175         }
 176
 177         /* Since we may have introduced old->new references, need to revisit
 178         all objects and code blocks on a minor GC. */
 179         data->mark_all_cards();
 180
 181         {
 182                 code_block_write_barrier_visitor code_block_visitor(code);
 183                 each_code_block(code_block_visitor);
 184         }
 185 }
 186
 187 }