Do not try to serialize VM objects, these are read only canonical objects and should be referred to…

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"
 #include "vm/heap.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/symbols.h"
 
 namespace dart {
 
 enum {
   kInstanceId = ObjectStore::kMaxId,
   kMaxPredefinedObjectIds,
 };
 static const int kNumInitialReferencesInFullSnapshot = 160 * KB;
 static const int kNumInitialReferences = 4;
 
@@ skipping 100 matching lines @@
 
 RawObject* SnapshotReader::ReadObjectImpl() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == 0) {
     return Integer::New((value >> kSmiTagShift));
   }
   return ReadObjectImpl(value);
 }
 
 
-RawObject* SnapshotReader::ReadObjectImpl(intptr_t value) {
-  ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
-  SerializedHeaderType header_type = SerializedHeaderTag::decode(value);
-  intptr_t header_value = SerializedHeaderData::decode(value);
-
-  if (header_type == kObjectId) {
-    return ReadIndexedObject(header_value);
+RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value) {
+  ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
+  if (IsVMIsolateObject(header_value)) {
+    return ReadVMIsolateObject(header_value);
+  } else {
+    if (SerializedHeaderTag::decode(header_value) == kObjectId) {
+      return ReadIndexedObject(SerializedHeaderData::decode(header_value));
+    }
+    ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
+    return ReadInlinedObject(SerializedHeaderData::decode(header_value));
   }
-  ASSERT(header_type == kInlined);
-  return ReadInlinedObject(header_value);
 }
 
 
 RawObject* SnapshotReader::ReadObjectRef() {
-  int64_t value = Read<int64_t>();
-  if ((value & kSmiTagMask) == 0) {
-    return Integer::New((value >> kSmiTagShift));
+  int64_t header_value = Read<int64_t>();
+  if ((header_value & kSmiTagMask) == 0) {
+    return Integer::New((header_value >> kSmiTagShift));
   }
-  ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
-  SerializedHeaderType header_type = SerializedHeaderTag::decode(value);
-  intptr_t header_value = SerializedHeaderData::decode(value);
-
-  if (header_type == kObjectId) {
-    return ReadIndexedObject(header_value);
+  ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
+  if (IsVMIsolateObject(header_value)) {
+    return ReadVMIsolateObject(header_value);
+  } else if (SerializedHeaderTag::decode(header_value) == kObjectId) {
+    return ReadIndexedObject(SerializedHeaderData::decode(header_value));
   }
-  ASSERT(header_type == kInlined);
-  intptr_t object_id = header_value;
+  ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
+  intptr_t object_id = SerializedHeaderData::decode(header_value);
   ASSERT(GetBackRef(object_id) == NULL);
 
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
   // Since we are only reading an object reference, If it is an instance kind
   // then we only need to figure out the class of the object and allocate an
   // instance of it. The individual fields will be read later.
   if (SerializedHeaderData::decode(class_header) == kInstanceId) {
     Instance& result = Instance::ZoneHandle(isolate(), Instance::null());
@@ skipping 290 matching lines @@
 }
 
 
 RawGrowableObjectArray* SnapshotReader::NewGrowableObjectArray() {
   ALLOC_NEW_OBJECT(GrowableObjectArray,
                    object_store()->growable_object_array_class());
 }
 
 
 RawClass* SnapshotReader::LookupInternalClass(intptr_t class_header) {
-  SerializedHeaderType header_type = SerializedHeaderTag::decode(class_header);
-
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
-  if (header_type == kObjectId) {
+  if (IsVMIsolateObject(class_header)) {
+    intptr_t class_id = GetVMIsolateObjectId(class_header);
+    if (IsSingletonClassId(class_id)) {
+      return Object::GetSingletonClass(class_id);  // return singleton.
+    }
+  } else if (SerializedHeaderTag::decode(class_header) == kObjectId) {
     intptr_t header_value = SerializedHeaderData::decode(class_header);
     if (IsObjectStoreClassId(header_value)) {
       return object_store()->GetClass(header_value);
-    } else if (IsSingletonClassId(header_value)) {
-      return Object::GetSingletonClass(header_value);  // return the singleton.
     }
   }
   return Class::null();
 }
 
 
 RawObject* SnapshotReader::AllocateUninitialized(const Class& cls,
                                                  intptr_t size) {
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
@@ skipping 12 matching lines @@
   uword tags = 0;
   intptr_t index = cls.id();
   ASSERT(index != kIllegalObjectKind);
   tags = RawObject::ClassIdTag::update(index, tags);
   tags = RawObject::SizeTag::update(size, tags);
   raw_obj->ptr()->tags_ = tags;
   return raw_obj;
 }
 
 
-RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id) {
+RawObject* SnapshotReader::ReadVMIsolateObject(intptr_t header_value) {
+  intptr_t object_id = GetVMIsolateObjectId(header_value);
   if (object_id == Object::kNullObject) {
     // This is a singleton null object, return it.
     return Object::null();
   }
   if (object_id == Object::kSentinelObject) {
     return Object::sentinel();
   }
   if (IsSingletonClassId(object_id)) {
     return Object::GetSingletonClass(object_id);  // return singleton object.
-  } else if (IsObjectStoreClassId(object_id)) {
+  } else {
+    ASSERT(Symbols::IsVMSymbolId(object_id));
+    return Symbols::GetVMSymbol(object_id);  // return VM symbol.
+  }
+  UNREACHABLE();
+}
+
+
+RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id) {
+  if (IsObjectStoreClassId(object_id)) {
     return object_store()->GetClass(object_id);
   } else if (object_id == ObjectStore::kTrueValue) {
     return object_store()->true_value();
   } else if (object_id == ObjectStore::kFalseValue) {
     return object_store()->false_value();
   } else if (kind_ != Snapshot::kFull) {
     if (IsObjectStoreTypeId(object_id)) {
       return object_store()->GetType(object_id);  // return type object.
     }
   }
@@ skipping 79 matching lines @@
   }
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj);
   WriteForwardedObjects();
 }
 
 
+void SnapshotWriter::HandleVMIsolateObject(RawObject* rawobj) {
+  // Check if it is a singleton null object.
+  if (rawobj == Object::null()) {
+    WriteVMIsolateObject(Object::kNullObject);
+    return;
+  }
+
+  // Check if it is a singleton sentinel object.
+  if (rawobj == Object::sentinel()) {
+    WriteVMIsolateObject(Object::kSentinelObject);
+    return;
+  }
+
+  // Check if it is a singleton class object.
+  RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
+  intptr_t index = Object::GetSingletonClassIndex(raw_class);
+  if (index != Object::kInvalidIndex) {
+    WriteVMIsolateObject(index);
+    return;
+  }
+
+  // Check it is a predefined symbol.
+  index = Symbols::LookupVMSymbol(rawobj);
+  if (index != Object::kInvalidIndex) {
+    WriteVMIsolateObject(index);
+    return;
+  }
+
+  UNREACHABLE();
+}
+
+
 void SnapshotWriter::WriteObjectRef(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
   // Check if object has already been serialized, in that
   // case just write the object id out.
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
     WriteIndexedObject(id);
     return;
   }
 
   NoGCScope no_gc;
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
 
   ObjectKind obj_kind = cls->ptr()->instance_kind_;
   if (obj_kind == Instance::kInstanceKind) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     // Write out the serialization header value for this object.
-    WriteSerializationMarker(kInlined, object_id);
+    WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
     WriteIntptrValue(SerializedHeaderData::encode(kInstanceId));
 
     // Write out the class information for this object.
     WriteObjectImpl(cls);
 
     return;
   }
   if (obj_kind == Array::kInstanceKind) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
-    WriteSerializationMarker(kInlined, object_id);
+    WriteInlinedObjectHeader(object_id);
 
     // Write out the class information.
     WriteIndexedObject(ObjectStore::kArrayClass);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   if (obj_kind == ImmutableArray::kInstanceKind) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
-    WriteSerializationMarker(kInlined, object_id);
+    WriteInlinedObjectHeader(object_id);
 
     // Write out the class information.
     WriteIndexedObject(ObjectStore::kImmutableArrayClass);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   // Object is being referenced, add it to the forward ref list and mark
@@ skipping 80 matching lines @@
   // - Object that has already been written: (negative id in stream | 0x3)
 
   NoGCScope no_gc;
 
   // First check if it is a Smi (i.e not a heap object).
   if (!rawobj->IsHeapObject()) {
     Write<int64_t>(reinterpret_cast<intptr_t>(rawobj));
     return true;
   }
 
-  // Check if it is a singleton null object which is shared by all isolates.
-  if (rawobj == Object::null()) {
-    WriteIndexedObject(Object::kNullObject);
+  // Check if object has already been serialized, in that case just write
+  // the object id out.
+  uword tags = rawobj->ptr()->tags_;
+  if (SerializedHeaderTag::decode(tags) == kObjectId) {
+    intptr_t id = SerializedHeaderData::decode(tags);
+    WriteIndexedObject(id);
     return true;
   }
 
-  // Check if it is a singleton sentinel object which is shared by all isolates.
-  if (rawobj == Object::sentinel()) {
-    WriteIndexedObject(Object::kSentinelObject);
-    return true;
-  }
-
-  // Check if it is a singleton class object which is shared by
-  // all isolates.
-  RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
-  intptr_t index = Object::GetSingletonClassIndex(raw_class);
-  if (index != Object::kInvalidIndex) {
-    WriteIndexedObject(index);
+  // Now check if it is an object from the VM isolate (NOTE: premarked objects
+  // are considered to be objects in the VM isolate). These objects are shared
+  // by all isolates.
+  if (rawobj->IsMarked()) {
+    HandleVMIsolateObject(rawobj);
     return true;
   }
 
   // Check if it is a singleton boolean true value.
   if (rawobj == object_store()->true_value()) {
     WriteIndexedObject(ObjectStore::kTrueValue);
     return true;
   }
 
   // Check if it is a singleton boolean false value.
   if (rawobj == object_store()->false_value()) {
     WriteIndexedObject(ObjectStore::kFalseValue);
     return true;
   }
 
   // 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 (RawObject::ClassIdTag::decode(GetObjectTags(rawobj)) == kCode) {
-    WriteIndexedObject(Object::kNullObject);
+  if (rawobj->GetClassId() == kCode) {
+    WriteVMIsolateObject(Object::kNullObject);
     return true;
   }
 
   // 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);
+    intptr_t index = object_store()->GetTypeIndex(raw_type);
     if (index != ObjectStore::kInvalidIndex) {
       WriteIndexedObject(index);
       return true;
     }
   }
 
   return false;
 }
 
 
 void SnapshotWriter::WriteObjectImpl(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
-  // Check if object has already been serialized, in that
-  // case just write the object id out.
-  uword tags = raw->ptr()->tags_;
-  if (SerializedHeaderTag::decode(tags) == kObjectId) {
-    intptr_t id = SerializedHeaderData::decode(tags);
-    WriteIndexedObject(id);
-    return;
-  }
-
   // 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.
   MarkObject(raw, kIsSerialized);
 
   WriteInlinedObject(raw);
 }
 
 
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
-  // Assert object is not a simple predefined type.
-  ASSERT(!CheckAndWritePredefinedObject(raw));
-
   // Now write the object out inline in the stream as follows:
   // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
   NoGCScope no_gc;
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
   intptr_t object_id = SerializedHeaderData::decode(tags);
   tags = forward_list_[object_id - kMaxPredefinedObjectIds]->tags();
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
   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);
+    WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
     WriteIntptrValue(SerializedHeaderData::encode(kInstanceId));
 
     // Write out the tags.
     WriteIntptrValue(tags);
 
     // Write out the class information for this object.
     WriteObjectImpl(cls);
 
@@ skipping 37 matching lines @@
       // Mark object as serialized.
       forward_list_[i]->set_state(kIsSerialized);
     }
   }
 }
 
 
 void SnapshotWriter::WriteClassId(RawClass* cls) {
   ASSERT(kind_ != Snapshot::kFull);
   int id = object_store()->GetClassIndex(cls);
-  if (IsSingletonClassId(id) || IsObjectStoreClassId(id)) {
+  if (IsSingletonClassId(id)) {
+    WriteVMIsolateObject(id);
+  } else if (IsObjectStoreClassId(id)) {
     WriteIndexedObject(id);
   } else {
     // TODO(5411462): Should restrict this to only core-lib classes in this
     // case.
     // Write out the class and tags information.
-    WriteObjectHeader(Object::kClassClass, GetObjectTags(cls));
+    WriteVMIsolateObject(Object::kClassClass);
+    WriteIntptrValue(GetObjectTags(cls));
 
     // Write out the library url and class name.
     RawLibrary* library = cls->ptr()->library_;
     ASSERT(library != Library::null());
     WriteObjectImpl(library->ptr()->url_);
     WriteObjectImpl(cls->ptr()->name_);
   }
 }
 
 
 void SnapshotWriter::ArrayWriteTo(intptr_t object_id,
                                   intptr_t array_kind,
                                   intptr_t tags,
                                   RawSmi* length,
                                   RawAbstractTypeArguments* type_arguments,
                                   RawObject* data[]) {
   intptr_t len = Smi::Value(length);
 
   // Write out the serialization header value for this object.
-  WriteSerializationMarker(kInlined, object_id);
+  WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  WriteObjectHeader(array_kind, tags);
+  WriteIndexedObject(array_kind);
+  WriteIntptrValue(tags);
 
   // Write out the length field.
   Write<RawObject*>(length);
 
   // Write out the type arguments.
   WriteObjectImpl(type_arguments);
 
   // Write out the individual object ids.
   for (intptr_t i = 0; i < len; i++) {
     WriteObjectRef(data[i]);
@@ skipping 17 matching lines @@
     RawObject* raw_obj = *current;
     if (as_references_) {
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 }  // namespace dart