vm/objects.cpp

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