Request for comments on overall approach.

runtime/vm/snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
@@ skipping 346 matching lines @@
   uword address = heap->TryAllocate(size, Heap::kOld);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
     const Instance& exception =
         Instance::Handle(object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
-  raw_obj->ptr()->class_ = cls.raw();
   uword tags = 0;
   intptr_t index = cls.index();
   ASSERT(index != kIllegalObjectKind);
   tags = RawObject::ClassTag::update(index, tags);
   tags = RawObject::SizeTag::update(size, tags);
   raw_obj->ptr()->tags_ = tags;
   return raw_obj;
 }
 
 
@@ skipping 138 matching lines @@
   }
 
   // Check if it is a singleton boolean false value.
   if (rawobj == object_store()->false_value()) {
     WriteIndexedObject(ObjectStore::kFalseValue);
     return;
   }
 
   // Check if it is a code object in that case just write a Null object
   // as we do not want code objects in the snapshot.
-  if (rawobj->ptr()->class_ == Object::code_class()) {
+  if (RawObject::GetClass(GetObjectTags(rawobj)) == Object::code_class()) {
     WriteIndexedObject(Object::kNullObject);
     return;
   }
 
   // Check if classes are not being serialized and it is preinitialized type.
   if (kind_ != Snapshot::kFull) {
     RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
     index = object_store()->GetTypeIndex(raw_type);
     if (index != ObjectStore::kInvalidIndex) {
       WriteIndexedObject(index);
       return;
     }
   }
 
   // Now write the object out inline in the stream.
   WriteInlinedObject(rawobj);
 }
 
 
 void SnapshotWriter::UnmarkAll() {
   NoGCScope no_gc;
   for (intptr_t i = 0; i < forward_list_.length(); i++) {
     RawObject* raw = forward_list_[i]->raw();
-    raw->ptr()->class_ = forward_list_[i]->cls();  // Restore original class.
+    raw->ptr()->tags_ = forward_list_[i]->tags();  // Restore original class.
   }
 }
 
 
 void SnapshotWriter::WriteFullSnapshot() {
   ASSERT(kind_ == Snapshot::kFull);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
 
   // Write out all the objects in the object store of the isolate which
   // is the root set for all dart allocated objects at this point.
   SnapshotWriterVisitor visitor(this);
   object_store->VisitObjectPointers(&visitor);
 
   // Finalize the snapshot buffer.
   FinalizeBuffer();
 }
 
 
+uword SnapshotWriter::GetObjectTags(RawObject* raw) {
+  uword tags = raw->ptr()->tags_;
+  if (SerializedHeaderTag::decode(tags) == kObjectId) {
+    intptr_t id = SerializedHeaderData::decode(tags);
+    return forward_list_[id - kMaxPredefinedObjectIds]->tags();
+  } else {
+    return tags;
+  }
+}
+
+
 intptr_t SnapshotWriter::MarkObject(RawObject* raw, RawClass* cls) {
   NoGCScope no_gc;
   intptr_t object_id = forward_list_.length() + kMaxPredefinedObjectIds;
   ASSERT(object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
-  raw->ptr()->class_ = reinterpret_cast<RawClass*>(value);
-  ForwardObjectNode* node = new ForwardObjectNode(raw, cls);
+  uword tags = raw->ptr()->tags_;
+  raw->ptr()->tags_ = value;
+  ForwardObjectNode* node = new ForwardObjectNode(raw, tags);
   ASSERT(node != NULL);
   forward_list_.Add(node);
   return object_id;
 }
 
 
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   NoGCScope no_gc;
-  RawClass* cls = raw->ptr()->class_;
+  uword tags = raw->ptr()->tags_;
 
   // Check if object has already been serialized, in that
   // case just write the object id out.
-  if (SerializedHeaderTag::decode(reinterpret_cast<uword>(cls)) == kObjectId) {
-    intptr_t id = SerializedHeaderData::decode(reinterpret_cast<intptr_t>(cls));
+  if (SerializedHeaderTag::decode(tags) == kObjectId) {
+    intptr_t id = SerializedHeaderData::decode(tags);
     WriteIndexedObject(id);
     return;
   }
 
+  RawClass* cls = raw->GetClass();
+
   // Object is being serialized, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // an object id, instead of trying to serialize it again.
   intptr_t object_id = MarkObject(raw, cls);
 
   ObjectKind kind = cls->ptr()->instance_kind_;
   if (kind == Instance::kInstanceKind) {
     // Object is regular dart instance.
     // TODO(5411462): figure out what we need to do if an object with native
     // fields is serialized (throw exception or serialize a null object).
     ASSERT(cls->ptr()->num_native_fields_ == 0);
     intptr_t instance_size = cls->ptr()->instance_size_;
     ASSERT(instance_size != 0);
 
     // Write out the serialization header value for this object.
     WriteSerializationMarker(kInlined, object_id);
 
     // Indicate this is an instance object.
     WriteIntptrValue(SerializedHeaderData::encode(kInstanceId));
 
     // Write out the tags.
-    WriteIntptrValue(raw->ptr()->tags_);
+    WriteIntptrValue(tags);
 
     // Write out the class information for this object.
     WriteObject(cls);
 
     // Write out all the fields for the object.
     intptr_t offset = Object::InstanceSize();
     while (offset < instance_size) {
       WriteObject(*reinterpret_cast<RawObject**>(
           reinterpret_cast<uword>(raw->ptr()) + offset));
       offset += kWordSize;
@@ skipping 48 matching lines @@
 
 
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
     writer_->WriteObject(raw_obj);
   }
 }
 
 }  // namespace dart