vm/objects.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 void factor_vm::primitive_special_object()
   7 {
   8         fixnum e = untag_fixnum(dpeek());
   9         drepl(special_objects[e]);
  10 }
  11
  12 void factor_vm::primitive_set_special_object()
  13 {
  14         fixnum e = untag_fixnum(dpop());
  15         cell value = dpop();
  16         special_objects[e] = value;
  17 }
  18
  19 void factor_vm::primitive_identity_hashcode()
  20 {
  21         cell tagged = dpeek();
  22         object *obj = untag<object>(tagged);
  23         drepl(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>(dpop());
  36         compute_identity_hashcode(obj);
  37 }
  38
  39 void factor_vm::primitive_set_slot()
  40 {
  41         fixnum slot = untag_fixnum(dpop());
  42         object *obj = untag<object>(dpop());
  43         cell value = dpop();
  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         drepl(clone_object(dpeek()));
  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 void factor_vm::primitive_size()
  81 {
  82         box_unsigned_cell(object_size(dpop()));
  83 }
  84
  85 struct slot_become_visitor {
  86         std::map<object *,object *> *become_map;
  87
  88         explicit slot_become_visitor(std::map<object *,object *> *become_map_) :
  89                 become_map(become_map_) {}
  90
  91         object *operator()(object *old)
  92         {
  93                 std::map<object *,object *>::const_iterator iter = become_map->find(old);
  94                 if(iter != become_map->end())
  95                         return iter->second;
  96                 else
  97                         return old;
  98         }
  99 };
 100
 101 struct object_become_visitor {
 102         slot_visitor<slot_become_visitor> *workhorse;
 103
 104         explicit object_become_visitor(slot_visitor<slot_become_visitor> *workhorse_) :
 105                 workhorse(workhorse_) {}
 106
 107         void operator()(object *obj)
 108         {
 109                 workhorse->visit_slots(obj);
 110         }
 111 };
 112
 113 /* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this
 114    to coalesce equal but distinct quotations and wrappers. */
 115 void factor_vm::primitive_become()
 116 {
 117         array *new_objects = untag_check<array>(dpop());
 118         array *old_objects = untag_check<array>(dpop());
 119
 120         cell capacity = array_capacity(new_objects);
 121         if(capacity != array_capacity(old_objects))
 122                 critical_error("bad parameters to become",0);
 123
 124         /* Build the forwarding map */
 125         std::map<object *,object *> become_map;
 126
 127         for(cell i = 0; i < capacity; i++)
 128         {
 129                 tagged<object> old_obj(array_nth(old_objects,i));
 130                 tagged<object> new_obj(array_nth(new_objects,i));
 131
 132                 if(old_obj != new_obj)
 133                         become_map[old_obj.untagged()] = new_obj.untagged();
 134         }
 135
 136         /* Update all references to old objects to point to new objects */
 137         slot_visitor<slot_become_visitor> workhorse(this,slot_become_visitor(&become_map));
 138         workhorse.visit_roots();
 139         workhorse.visit_contexts();
 140
 141         object_become_visitor object_visitor(&workhorse);
 142         each_object(object_visitor);
 143
 144         /* Since we may have introduced old->new references, need to revisit
 145         all objects on a minor GC. */
 146         data->mark_all_cards();
 147         primitive_minor_gc();
 148
 149         /* If a word's definition quotation was in old_objects and the
 150            quotation in new_objects is not compiled, we might leak memory
 151            by referencing the old quotation unless we recompile all
 152            unoptimized words. */
 153         compile_all_words();
 154
 155         /* Update references to old objects in the code heap */
 156         update_code_heap_words_and_literals();
 157 }
 158
 159 }