Changes to create an application snapshot which can be layered on top

vm/raw_object_snapshot.cc

 // Copyright (c) 2011, 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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
@@ skipping 11 matching lines @@
 }
 
 
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   Class& cls = Class::ZoneHandle();
-  if (kind == Snapshot::kFull) {
+  if ((kind == Snapshot::kFull) ||
+      (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) {

[Ivan Posva, 2011/12/19 21:32:42]

I am wondering if there is a way to simplify the logic here. The snapshot writer
should be able to communicate in the tags which way to branch here is my
expectation.

[siva, 2011/12/19 23:50:00]

I would have to think about how this can be done by using information purely
from the writer. Let me do this in another CL.

On 2011/12/19 21:32:42, Ivan Posva wrote:

     // Read in the base information.
     ObjectKind kind = reader->Read<ObjectKind>();
 
     // Allocate class object of specified kind.
     cls = Class::GetClass(kind);
     reader->AddBackwardReference(object_id, &cls);
 
     // Set the object tags.
     cls.set_tags(tags);
 
@@ skipping 21 matching lines @@
     cls ^= reader->ReadClassId(object_id);
   }
   return cls.raw();
 }
 
 
 void RawClass::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
-  if (kind == Snapshot::kFull) {
+  if ((kind == Snapshot::kFull) ||
+      (kind == Snapshot::kScript && !IsCreatedFromSnapshot())) {
     // Write out the class and tags information.
     writer->WriteObjectHeader(Object::kClassClass, ptr()->tags_);
 
     // Write out all the non object pointer fields.
     // NOTE: cpp_vtable_ is not written.
     writer->Write<ObjectKind>(ptr()->instance_kind_);
     writer->Write<intptr_t>(ptr()->instance_size_);
     writer->Write<intptr_t>(ptr()->type_arguments_instance_field_offset_);
     writer->Write<intptr_t>(ptr()->next_field_offset_);
     writer->Write<intptr_t>(ptr()->num_native_fields_);
     writer->Write<int8_t>(ptr()->class_state_);
     writer->Write<bool>(ptr()->is_const_);
     writer->Write<bool>(ptr()->is_interface_);
 
     // Write out all the object pointer fields.
+    SnapshotWriterVisitor visitor(writer);
     visitor.VisitPointers(from(), to());
   } else {
     writer->WriteClassId(this);
   }
 }
 
 
 RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
@@ skipping 20 matching lines @@
     *(unresolved_class.raw()->from() + i) = reader->ReadObject();
   }
   return unresolved_class.raw();
 }
 
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kUnresolvedClassClass, ptr()->tags_);
 
   // Write out all the non object pointer fields.
   writer->Write<intptr_t>(ptr()->token_index_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawAbstractType* AbstractType::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   UNREACHABLE();  // AbstractType is an abstract class.
   return NULL;
@@ skipping 24 matching lines @@
   parameterized_type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (parameterized_type.raw()->to() -
                        parameterized_type.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(parameterized_type.raw()->from() + i) = reader->ReadObject();
   }
+
+  // If object needs to be a canonical object, Canonicalize it.
+  if ((kind != Snapshot::kFull) && parameterized_type.IsCanonical()) {
+    parameterized_type ^= parameterized_type.Canonicalize();
+  }
   return parameterized_type.raw();
 }
 
 
 void RawType::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTypeClass, ptr()->tags_);
 
   // Write out all the non object pointer fields.
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
@@ skipping 19 matching lines @@
   }
 
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTypeParameterClass, ptr()->tags_);
 
   // Write out all the non object pointer fields.
   writer->Write<intptr_t>(ptr()->index_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawInstantiatedType* InstantiatedType::ReadFrom(SnapshotReader* reader,
                                                 intptr_t object_id,
                                                 intptr_t tags,
                                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
@@ skipping 16 matching lines @@
   }
   return instantiated_type.raw();
 }
 
 
 void RawInstantiatedType::WriteTo(SnapshotWriter* writer,
                                   intptr_t object_id,
                                   Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kInstantiatedTypeClass, ptr()->tags_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawAbstractTypeArguments* AbstractTypeArguments::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
     Snapshot::Kind kind) {
   UNREACHABLE();  // AbstractTypeArguments is an abstract class.
@@ skipping 22 matching lines @@
       TypeArguments::Handle(TypeArguments::New(len));
   reader->AddBackwardReference(object_id, &type_arguments);
 
   // Now set all the object fields.
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type ^= reader->ReadObject();
     type_arguments.SetTypeAt(i, type);
   }
 
-  // Set the object tags.
+  // Set the object tags (This is done after setting the object fields
+  // because 'SetTypeAt' has an assertion to check if the object is not
+  // already canonical).
   type_arguments.set_tags(tags);
 
+  // If object needs to be a canonical object, Canonicalize it.
+  if ((kind != Snapshot::kFull) && type_arguments.IsCanonical()) {
+    type_arguments ^= type_arguments.Canonicalize();
+  }
   return type_arguments.raw();
 }
 
 
 void RawTypeArguments::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
@@ skipping 39 matching lines @@
   }
   return instantiated_type_arguments.raw();
 }
 
 
 void RawInstantiatedTypeArguments::WriteTo(SnapshotWriter* writer,
                                            intptr_t object_id,
                                            Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kInstantiatedTypeArgumentsClass,
                             ptr()->tags_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawFunction* Function::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate function object.
   Function& func = Function::ZoneHandle(Function::New());
   reader->AddBackwardReference(object_id, &func);
 
   // Set the object tags.
   func.set_tags(tags);
 
   // Set all the non object fields.
   func.set_token_index(reader->Read<intptr_t>());
@@ skipping 15 matching lines @@
   }
 
   return func.raw();
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
+  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kFunctionClass, ptr()->tags_);
 
   // Write out all the non object fields.
   writer->Write<intptr_t>(ptr()->token_index_);
   writer->Write<intptr_t>(ptr()->num_fixed_parameters_);
   writer->Write<intptr_t>(ptr()->num_optional_parameters_);
   writer->Write<intptr_t>(ptr()->invocation_counter_);
   writer->Write<intptr_t>(ptr()->deoptimization_counter_);
   writer->Write<intptr_t>(ptr()->kind_);
   writer->Write<bool>(ptr()->is_static_);
   writer->Write<bool>(ptr()->is_const_);
   writer->Write<bool>(ptr()->is_optimizable_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate field object.
   Field& field = Field::ZoneHandle(Field::New());
   reader->AddBackwardReference(object_id, &field);
 
   // Set the object tags.
   field.set_tags(tags);
 
   // Set all non object fields.
   field.set_token_index(reader->Read<intptr_t>());
@@ skipping 10 matching lines @@
   }
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
+  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kFieldClass, ptr()->tags_);
 
+  // Write out all the non object fields.
   writer->Write<intptr_t>(ptr()->token_index_);
   writer->Write<bool>(ptr()->is_static_);
   writer->Write<bool>(ptr()->is_final_);
   writer->Write<bool>(ptr()->has_initializer_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Read the length so that we can determine number of tokens to read.
   RawSmi* smi_len = GetSmi(reader->Read<intptr_t>());
   intptr_t len = Smi::Value(smi_len);
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(TokenStream::New(len));
   reader->AddBackwardReference(object_id, &token_stream);
 
   // Set the object tags.
   token_stream.set_tags(tags);
 
   // Read the token stream into the TokenStream.
   String& literal = String::Handle();
   for (intptr_t i = 0; i < len; i++) {
     Token::Kind kind = static_cast<Token::Kind>(
         Smi::Value(GetSmi(reader->Read<intptr_t>())));
     literal ^= reader->ReadObject();
     token_stream.SetTokenAt(i, kind, literal);
   }
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
+  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTokenStreamClass, ptr()->tags_);
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the token stream (token kind and literal).
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < TokenStream::StreamLength(len); i++) {
     writer->WriteObject(ptr()->data_[i]);
   }
 }
 
 
 RawScript* Script::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate script object.
   Script& script = Script::ZoneHandle(Script::New());
   reader->AddBackwardReference(object_id, &script);
 
   // Set the object tags.
   script.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (script.raw()->to() - script.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(script.raw()->from() + i) = reader->ReadObject();
   }
 
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
-  SnapshotWriterVisitor visitor(writer);
+  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kScriptClass, ptr()->tags_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawLibrary* Library::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage);
 
-  // Allocate library object.
-  Library& library = Library::ZoneHandle(Library::New());
+  Library& library = Library::ZoneHandle();
   reader->AddBackwardReference(object_id, &library);
 
-  // Set the object tags.
-  library.set_tags(tags);
+  if (RawObject::IsCreatedFromSnapshot(tags)) {
+    ASSERT(kind != Snapshot::kFull);
+    // Lookup the object as it should already exist in the heap.
+    String& library_url = String::Handle();
+    library_url ^= reader->ReadObject();
+    library = Library::LookupLibrary(library_url);
+  } else {
+    // Allocate library object.
+    library = Library::New();
 
-  // Set all non object fields.
-  library.raw_ptr()->num_imports_ = reader->Read<intptr_t>();
-  library.raw_ptr()->num_imported_into_ = reader->Read<intptr_t>();
-  library.raw_ptr()->num_anonymous_ = reader->Read<intptr_t>();
-  library.raw_ptr()->corelib_imported_ = reader->Read<bool>();
-  library.raw_ptr()->load_state_ = reader->Read<int8_t>();
-  // The native resolver is not serialized.
-  Dart_NativeEntryResolver resolver = reader->Read<Dart_NativeEntryResolver>();
-  ASSERT(resolver == NULL);
-  library.set_native_entry_resolver(resolver);
+    // Set the object tags.
+    library.set_tags(tags);
 
-  // Set all the object fields.
-  // TODO(5411462): Need to assert No GC can happen here, even though
-  // allocations may happen.
-  intptr_t num_flds = (library.raw()->to() - library.raw()->from());
-  for (intptr_t i = 0; i <= num_flds; i++) {
-    *(library.raw()->from() + i) = reader->ReadObject();
+    // Set all non object fields.
+    library.raw_ptr()->num_imports_ = reader->Read<intptr_t>();
+    library.raw_ptr()->num_imported_into_ = reader->Read<intptr_t>();
+    library.raw_ptr()->num_anonymous_ = reader->Read<intptr_t>();
+    library.raw_ptr()->corelib_imported_ = reader->Read<bool>();
+    library.raw_ptr()->load_state_ = reader->Read<int8_t>();
+    // The native resolver is not serialized.
+    Dart_NativeEntryResolver resolver =
+        reader->Read<Dart_NativeEntryResolver>();
+    ASSERT(resolver == NULL);
+    library.set_native_entry_resolver(resolver);
+
+    // Set all the object fields.
+    // TODO(5411462): Need to assert No GC can happen here, even though
+    // allocations may happen.
+    intptr_t num_flds = (library.raw()->to() - library.raw()->from());
+    for (intptr_t i = 0; i <= num_flds; i++) {
+      *(library.raw()->from() + i) = reader->ReadObject();
+    }
   }
-
   return library.raw();
 }
 
 
 void RawLibrary::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
+  ASSERT(kind != Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kLibraryClass, ptr()->tags_);
 
-  writer->Write<intptr_t>(ptr()->num_imports_);
-  writer->Write<intptr_t>(ptr()->num_imported_into_);
-  writer->Write<intptr_t>(ptr()->num_anonymous_);
-  writer->Write<bool>(ptr()->corelib_imported_);
-  writer->Write<int8_t>(ptr()->load_state_);
-  // We do not serialize the native resolver over, this needs to be explicitly
-  // set after deserialization.
-  writer->Write<Dart_NativeEntryResolver>(NULL);
+  if (IsCreatedFromSnapshot()) {
+    ASSERT(kind != Snapshot::kFull);
+    // Write out library URL so that it can be looked up when reading.
+    writer->WriteObject(ptr()->url_);
+  } else {
+    // Write out all non object fields.
+    writer->Write<intptr_t>(ptr()->num_imports_);
+    writer->Write<intptr_t>(ptr()->num_imported_into_);
+    writer->Write<intptr_t>(ptr()->num_anonymous_);
+    writer->Write<bool>(ptr()->corelib_imported_);
+    writer->Write<int8_t>(ptr()->load_state_);
+    // We do not serialize the native resolver over, this needs to be explicitly
+    // set after deserialization.
+    writer->Write<Dart_NativeEntryResolver>(NULL);
 
-  // Write out all the object pointer fields.
-  visitor.VisitPointers(from(), to());
+    // Write out all the object pointer fields.
+    SnapshotWriterVisitor visitor(writer);
+    visitor.VisitPointers(from(), to());
+  }
 }
 
 
 RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate library prefix object.
   LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(LibraryPrefix::New());
   reader->AddBackwardReference(object_id, &prefix);
 
   // Set the object tags.
   prefix.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (prefix.raw()->to() - prefix.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(prefix.raw()->from() + i) = reader->ReadObject();
   }
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
+  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kLibraryPrefixClass, ptr()->tags_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawCode* Code::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage);
 
   // Create Code object.
   Code& code = Code::ZoneHandle(Code::New(0));
   reader->AddBackwardReference(object_id, &code);
   return code.raw();
 }
 
 
 void RawCode::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   // Currently we do not serialize any code and hence we write
   // out a null object for it.
   ASSERT(writer != NULL);
+  ASSERT(kind != Snapshot::kMessage);
 
   writer->WriteIndexedObject(Object::kNullObject);
 }
 
 
 RawInstructions* Instructions::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   UNREACHABLE();
@@ skipping 68 matching lines @@
   }
 
   return context.raw();
 }
 
 
 void RawContext::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kContextClass, ptr()->tags_);
 
   // Write out num of variables in the context.
   writer->Write<intptr_t>(ptr()->num_variables_);
 
   // Can't serialize the isolate pointer, we set it implicitly on read.
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
 
 RawContextScope* ContextScope::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
@@ skipping 16 matching lines @@
 
   return scope.raw();
 }
 
 
 void RawContextScope::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
-  SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kContextScopeClass, ptr()->tags_);
 
   // Serialize number of variables.
   writer->Write<intptr_t>(ptr()->num_variables_);
 
   // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
 
 RawUnhandledException* UnhandledException::ReadFrom(SnapshotReader* reader,
                                                     intptr_t object_id,
                                                     intptr_t tags,
                                                     Snapshot::Kind kind) {
   UNIMPLEMENTED();
   return UnhandledException::null();
@@ skipping 41 matching lines @@
 
 RawMint* Mint::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the 64 bit value for the object.
   int64_t value = reader->Read<int64_t>();
 
-  // Create a Mint object.
-  Mint& mint = Mint::ZoneHandle(
-      Mint::New(value, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
+  // Create a Mint object or get canonical one if it is a canonical constant.
+  Mint& mint = Mint::ZoneHandle();
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
+    mint = Mint::NewCanonical(value);
+  } else {
+    mint = Mint::New(value,
+                     (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew);
+  }
   reader->AddBackwardReference(object_id, &mint);
 
   // Set the object tags.
   mint.set_tags(tags);
 
   return mint.raw();
 }
 
 
 void RawMint::WriteTo(SnapshotWriter* writer,
@@ skipping 10 matching lines @@
   // Write out the 64 bit value.
   writer->Write<int64_t>(ptr()->value_);
 }
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+
   // Read in the HexCString representation of the bigint.
   intptr_t len = reader->Read<intptr_t>();
   char* str = reinterpret_cast<char*>(ZoneAllocator(len + 1));
   str[len] = '\0';
   for (intptr_t i = 0; i < len; i++) {
     str[i] = reader->Read<uint8_t>();
   }
+
   // Create a Bigint object from HexCString.
   Bigint& obj = Bigint::ZoneHandle(BigintOperations::FromHexCString(str));
+
+  // If it is a canonical constant make it one.
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
+    obj ^= obj.Canonicalize();
+  }
   reader->AddBackwardReference(object_id, &obj);
 
   // Set the object tags.
   obj.set_tags(tags);
 
   return obj.raw();
 }
 
 
 void RawBigint::WriteTo(SnapshotWriter* writer,
@@ skipping 18 matching lines @@
 }
 
 
 RawDouble* Double::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the double value for the object.
   double value = reader->Read<double>();
-  // Create a double object.
-  Double& dbl = Double::ZoneHandle(
-      Double::New(value, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
+
+  // Create a Double object or get canonical one if it is a canonical constant.
+  Double& dbl = Double::ZoneHandle();
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
+    dbl = Double::NewCanonical(value);
+  } else {
+    dbl = Double::New(value,
+                      (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew);
+  }
   reader->AddBackwardReference(object_id, &dbl);
 
   // Set the object tags.
   dbl.set_tags(tags);
 
   return dbl.raw();
 }
 
 
 void RawDouble::WriteTo(SnapshotWriter* writer,
@@ skipping 32 matching lines @@
 RawString* String::ReadFromImpl(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the length so that we can determine instance size to allocate.
   RawSmi* smi_len = GetSmi(reader->Read<intptr_t>());
   intptr_t len = Smi::Value(smi_len);
   RawSmi* smi_hash = GetSmi(reader->Read<intptr_t>());
 
-  // Set up the string object.
-  HandleType& str_obj = HandleType::ZoneHandle(HandleType::New(
-      len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
-  for (intptr_t i = 0; i < len; i++) {
-    *str_obj.CharAddr(i) = reader->Read<CharacterType>();
+  HandleType& str_obj = HandleType::ZoneHandle();
+  if (kind != Snapshot::kFull && RawObject::IsCanonical(tags)) {
+    CharacterType* ptr = reinterpret_cast<CharacterType*>(ZoneAllocator(len));
+    for (intptr_t i = 0; i < len; i++) {
+      ptr[i] = reader->Read<CharacterType>();
+    }
+    str_obj ^= String::NewSymbol(ptr, len);
+  } else {
+    // Set up the string object.
+    str_obj = HandleType::New(
+        len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew);
+    for (intptr_t i = 0; i < len; i++) {
+      *str_obj.CharAddr(i) = reader->Read<CharacterType>();
+    }
+    str_obj.set_tags(tags);
+    str_obj.SetHash(Smi::Value(smi_hash));
   }
   reader->AddBackwardReference(object_id, &str_obj);
 
-  // Set the object tags.
-  str_obj.set_tags(tags);
-
-  // Set up the hash value.
-  str_obj.SetHash(Smi::Value(smi_hash));
-
   return str_obj.raw();
 }
 
 
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   return static_cast<RawOneByteString*>(
       ReadFromImpl<OneByteString, uint8_t>(reader, object_id, tags, kind));
@@ skipping 388 matching lines @@
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObject(ptr()->pattern_);
   writer->Write<intptr_t>(ptr()->type_);
   writer->Write<intptr_t>(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 }  // namespace dart