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

vm/snapshot.h

 // 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.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 38 matching lines @@
 class RawTokenStream;
 class RawType;
 class RawTypeParameter;
 class RawTypeArguments;
 class RawTwoByteString;
 class RawUnresolvedClass;
 class String;
 
 // Serialized object header encoding is as follows:
 // - Smi: the Smi value is written as is (last bit is not tagged).
-// - VM internal type (from VM isolate): (index of type in vm isolate | 0x3)
-// - Object that has already been written: (negative id in stream | 0x3)
+// - VM object (from VM isolate): (object id in vm isolate | 0x3)
+//   This valus is serialized as a negative number.
+//   (note VM objects are never serialized they are expected to be found
+//    using ths unique ID assigned to them).
+// - Reference to object that has already been written: (object id | 0x3)
+//   This valus is serialized as a positive number.
 // - Object that is seen for the first time (inlined in the stream):
 //   (a unique id for this object | 0x1)
 enum SerializedHeaderType {
-  kInlined = 0x1,
+  kInlined  = 0x1,
   kObjectId = 0x3,
 };
 static const int8_t kHeaderTagBits = 2;
-static const int8_t kObjectIdTagBits = (kBitsPerWord - kHeaderTagBits);
-static const intptr_t kMaxObjectId = (kIntptrMax >> kHeaderTagBits);
+static const int8_t kObjectIdBits = (kBitsPerWord - (kHeaderTagBits + 1));
+static const intptr_t kMaxObjectId = (kUwordMax >> (kHeaderTagBits + 1));
+
 
 class SerializedHeaderTag : public BitField<enum SerializedHeaderType,
                                             0,
                                             kHeaderTagBits> {
 };
 
 
 class SerializedHeaderData : public BitField<intptr_t,
                                              kHeaderTagBits,
-                                             kObjectIdTagBits> {
+                                             kObjectIdBits> {
 };
 
 
 enum DeserializeState {
   kIsDeserialized = 0,
   kIsNotDeserialized = 1,
 };
 
 
 enum SerializeState {
@@ skipping 61 matching lines @@
     return value;
   }
 
   void ReadBytes(uint8_t* addr, intptr_t len) {
     stream_.ReadBytes(addr, len);
   }
 
   RawSmi* ReadAsSmi();
   intptr_t ReadSmiValue();
 
+  // Negative header value indicates VM isolate object id.
+  bool IsVMIsolateObject(intptr_t header_value) { return (header_value < 0); }
+  intptr_t GetVMIsolateObjectId(intptr_t header_val) {
+    ASSERT(IsVMIsolateObject(header_val));
+    intptr_t value = -header_val;  // Header is negative for VM isolate objects.
+    ASSERT(SerializedHeaderTag::decode(value) == kObjectId);
+    return SerializedHeaderData::decode(value);
+  }
+
  private:
   ReadStream stream_;  // input stream.
 };
 
 
 // Reads a snapshot into objects.
 class SnapshotReader : public BaseReader {
  public:
   SnapshotReader(const Snapshot* snapshot, Isolate* isolate);
   ~SnapshotReader() { }
@@ skipping 63 matching lines @@
   };
 
   // Allocate uninitialized objects, this is used when reading a full snapshot.
   RawObject* AllocateUninitialized(const Class& cls, intptr_t size);
 
   RawClass* ReadClassId(intptr_t object_id);
   RawObject* ReadObjectImpl();
   RawObject* ReadObjectImpl(intptr_t header);
   RawObject* ReadObjectRef();
 
-  // Read an object that was serialized as an Id (singleton, object store,
+  // Read a VM isolate object that was serialized as an Id.
+  RawObject* ReadVMIsolateObject(intptr_t object_id);
+
+  // Read an object that was serialized as an Id (singleton in object store,
   // or an object that was already serialized before).
   RawObject* ReadIndexedObject(intptr_t object_id);
 
   // Read an inlined object from the stream.
   RawObject* ReadInlinedObject(intptr_t object_id);
 
   // Based on header field check to see if it is an internal VM class.
   RawClass* LookupInternalClass(intptr_t class_header);
 
   void ArrayReadFrom(const Array& result, intptr_t len, intptr_t tags);
@@ skipping 42 matching lines @@
   template <typename T>
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
   }
 
   // Writes an intptr_t type value out.
   void WriteIntptrValue(intptr_t value) {
     Write<int64_t>(value);
   }
 
-  // Write an object that is serialized as an Id (singleton, object store,
+  // Write an object that is serialized as an Id (singleton in object store,
   // or an object that was already serialized before).
   void WriteIndexedObject(intptr_t object_id) {
-    WriteSerializationMarker(kObjectId, object_id);
+    ASSERT(object_id <= kMaxObjectId);
+    intptr_t value = 0;
+    value = SerializedHeaderTag::update(kObjectId, value);
+    value = SerializedHeaderData::update(object_id, value);
+    WriteIntptrValue(value);
   }
 
-  // Write out object header value.
-  void WriteObjectHeader(intptr_t class_id, intptr_t tags) {
-    // Write out the class information.
-    WriteIndexedObject(class_id);
-    // Write out the tags information.
-    WriteIntptrValue(tags);
+  // Write a VM Isolateobject that is serialized as an Id.
+  void WriteVMIsolateObject(intptr_t object_id) {
+    ASSERT(object_id <= kMaxObjectId);
+    intptr_t value = 0;
+    value = SerializedHeaderTag::update(kObjectId, value);
+    value = SerializedHeaderData::update(object_id, value);
+    WriteIntptrValue(-value);  // Write as a negative value.
   }
 
   // Write serialization header information for an object.
-  void WriteSerializationMarker(SerializedHeaderType type, intptr_t id) {
+  void WriteInlinedObjectHeader(intptr_t id) {
     ASSERT(id <= kMaxObjectId);
     intptr_t value = 0;
-    value = SerializedHeaderTag::update(type, value);
+    value = SerializedHeaderTag::update(kInlined, value);
     value = SerializedHeaderData::update(id, value);
     WriteIntptrValue(value);
   }
 
   // Write out a buffer of bytes.
   void WriteBytes(const uint8_t* addr, intptr_t len) {
     stream_.WriteBytes(addr, len);
   }
 
   // Finalize the serialized buffer by filling in the header information
@@ skipping 66 matching lines @@
     uword tags_;
     SerializeState state_;
 
     DISALLOW_COPY_AND_ASSIGN(ForwardObjectNode);
   };
 
   intptr_t MarkObject(RawObject* raw, SerializeState state);
   void UnmarkAll();
 
   bool CheckAndWritePredefinedObject(RawObject* raw);
+  void HandleVMIsolateObject(RawObject* raw);
 
   void WriteObjectRef(RawObject* raw);
   void WriteClassId(RawClass* cls);
   void WriteObjectImpl(RawObject* raw);
   void WriteInlinedObject(RawObject* raw);
   void WriteForwardedObjects();
   void ArrayWriteTo(intptr_t object_id,
                     intptr_t array_kind,
                     intptr_t tags,
                     RawSmi* length,
@@ skipping 58 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_