Make core snapshot word-size portable again.

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 60 matching lines @@
     RawObject** from = cls->from();
     RawObject** to = cls->to_snapshot(s->kind());
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kClassCid);
     intptr_t count = predefined_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawClass* cls = predefined_[i];
       intptr_t class_id = cls->ptr()->id_;
-      s->Write<intptr_t>(class_id);
+      s->WriteCid(class_id);
       s->AssignRef(cls);
     }
     count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawClass* cls = objects_[i];
       s->AssignRef(cls);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = predefined_.length();
     for (intptr_t i = 0; i < count; i++) {
       WriteClass(s, predefined_[i]);
@@ skipping 30 matching lines @@
 
 
 class ClassDeserializationCluster : public DeserializationCluster {
  public:
   ClassDeserializationCluster() { }
   virtual ~ClassDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     predefined_start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     ClassTable* table = d->isolate()->class_table();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t class_id = d->Read<intptr_t>();
+      intptr_t class_id = d->ReadCid();
       ASSERT(table->HasValidClassAt(class_id));
       RawClass* cls = table->At(class_id);
       ASSERT(cls != NULL);
       d->AssignRef(cls);
     }
     predefined_stop_index_ = d->next_index();
 
     start_index_ = d->next_index();
-    count = d->Read<intptr_t>();
+    count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          Class::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     Snapshot::Kind kind = d->kind();
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
     ClassTable* table = d->isolate()->class_table();
 
     for (intptr_t id = predefined_start_index_;
          id < predefined_stop_index_;
          id++) {
       RawClass* cls = reinterpret_cast<RawClass*>(d->Ref(id));
       RawObject** from = cls->from();
       RawObject** to_snapshot = cls->to_snapshot(kind);
       for (RawObject** p = from; p <= to_snapshot; p++) {
         *p = d->ReadRef();
       }
 
       intptr_t class_id = d->ReadCid();
       cls->ptr()->id_ = class_id;
-      cls->ptr()->instance_size_in_words_ = d->Read<int32_t>();
-      cls->ptr()->next_field_offset_in_words_ = d->Read<int32_t>();
+      if (!RawObject::IsInternalVMdefinedClassId(class_id)) {
+        cls->ptr()->instance_size_in_words_ = d->Read<int32_t>();
+        cls->ptr()->next_field_offset_in_words_ = d->Read<int32_t>();
+      } else {
+        d->Read<int32_t>();  // Skip.
+        d->Read<int32_t>();  // Skip.
+      }
       cls->ptr()->type_arguments_field_offset_in_words_ = d->Read<int32_t>();
       cls->ptr()->num_type_arguments_ = d->Read<uint16_t>();
       cls->ptr()->num_own_type_arguments_ = d->Read<uint16_t>();
       cls->ptr()->num_native_fields_ = d->Read<uint16_t>();
       cls->ptr()->token_pos_ = d->ReadTokenPosition();
       cls->ptr()->state_bits_ = d->Read<uint16_t>();
     }
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawClass* cls = reinterpret_cast<RawClass*>(d->Ref(id));
@@ skipping 65 matching lines @@
     RawObject** from = cls->from();
     RawObject** to = cls->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kUnresolvedClassCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawUnresolvedClass* cls = objects_[i];
       s->AssignRef(cls);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawUnresolvedClass* cls = objects_[i];
       RawObject** from = cls->from();
       RawObject** to = cls->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
       s->WriteTokenPosition(cls->ptr()->token_pos_);
     }
   }
 
  private:
   GrowableArray<RawUnresolvedClass*> objects_;
 };
 
 
 class UnresolvedClassDeserializationCluster : public DeserializationCluster {
  public:
   UnresolvedClassDeserializationCluster() { }
   virtual ~UnresolvedClassDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          UnresolvedClass::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 26 matching lines @@
     s->Push(type_args->ptr()->instantiations_);
     intptr_t length = Smi::Value(type_args->ptr()->length_);
     for (intptr_t i = 0; i < length; i++) {
       s->Push(type_args->ptr()->types()[i]);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kTypeArgumentsCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);

[siva, 2016/07/08 16:25:20]

How do you ensure that the count of objects being written fits in an int32_t
value? Is there are check somewhere when you are tracing through the objects?

[rmacnak, 2016/07/08 18:08:58]

Added check in Serializer::Serialize()

     for (intptr_t i = 0; i < count; i++) {
       RawTypeArguments* type_args = objects_[i];
       intptr_t length = Smi::Value(type_args->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(type_args);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawTypeArguments* type_args = objects_[i];
       intptr_t length = Smi::Value(type_args->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->Write<bool>(type_args->IsCanonical());
       intptr_t hash = Smi::Value(type_args->ptr()->hash_);
       s->Write<int32_t>(hash);
       s->WriteRef(type_args->ptr()->instantiations_);
       for (intptr_t j = 0; j < length; j++) {
         s->WriteRef(type_args->ptr()->types()[j]);
       }
     }
   }
 
  private:
   GrowableArray<RawTypeArguments*> objects_;
 };
 
 
 class TypeArgumentsDeserializationCluster : public DeserializationCluster {
  public:
   TypeArgumentsDeserializationCluster() { }
   virtual ~TypeArgumentsDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
                                          TypeArguments::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawTypeArguments* type_args =
           reinterpret_cast<RawTypeArguments*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(type_args, kTypeArgumentsCid,
                                      TypeArguments::InstanceSize(length),
                                      is_vm_object, is_canonical);
       type_args->ptr()->length_ = Smi::New(length);
       type_args->ptr()->hash_ = Smi::New(d->Read<int32_t>());
       type_args->ptr()->instantiations_ =
           reinterpret_cast<RawArray*>(d->ReadRef());
       for (intptr_t j = 0; j < length; j++) {
         type_args->ptr()->types()[j] =
@@ skipping 16 matching lines @@
     RawObject** from = cls->from();
     RawObject** to = cls->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kPatchClassCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawPatchClass* cls = objects_[i];
       s->AssignRef(cls);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawPatchClass* cls = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class PatchClassDeserializationCluster : public DeserializationCluster {
  public:
   PatchClassDeserializationCluster() { }
   virtual ~PatchClassDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          PatchClass::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 29 matching lines @@
       s->Push(func->ptr()->code_);
     } else if (s->kind() == Snapshot::kAppWithJIT) {
       s->Push(func->ptr()->unoptimized_code_);
       s->Push(func->ptr()->ic_data_array_);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kFunctionCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawFunction* func = objects_[i];
       s->AssignRef(func);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 37 matching lines @@
 
 
 class FunctionDeserializationCluster : public DeserializationCluster {
  public:
   FunctionDeserializationCluster() { }
   virtual ~FunctionDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          Function::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     Snapshot::Kind kind = d->kind();
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
@@ skipping 91 matching lines @@
     RawObject** from = data->from();
     RawObject** to = data->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kClosureDataCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawClosureData* data = objects_[i];
       s->AssignRef(data);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawClosureData* data = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class ClosureDataDeserializationCluster : public DeserializationCluster {
  public:
   ClosureDataDeserializationCluster() { }
   virtual ~ClosureDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          ClosureData::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 23 matching lines @@
     RawObject** from = data->from();
     RawObject** to = data->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kRedirectionDataCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawRedirectionData* data = objects_[i];
       s->AssignRef(data);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawRedirectionData* data = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class RedirectionDataDeserializationCluster : public DeserializationCluster {
  public:
   RedirectionDataDeserializationCluster() { }
   virtual ~RedirectionDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          RedirectionData::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 51 matching lines @@
     }
     if (kind != Snapshot::kAppNoJIT) {
       // Write out the guarded list length.
       s->Push(field->ptr()->guarded_list_length_);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kFieldCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawField* field = objects_[i];
       s->AssignRef(field);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 44 matching lines @@
 
 
 class FieldDeserializationCluster : public DeserializationCluster {
  public:
   FieldDeserializationCluster() { }
   virtual ~FieldDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Field::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     Snapshot::Kind kind = d->kind();
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 56 matching lines @@
     RawObject** from = token->from();
     RawObject** to = token->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kLiteralTokenCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawLiteralToken* token = objects_[i];
       s->AssignRef(token);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawLiteralToken* token = objects_[i];
@@ skipping 12 matching lines @@
 
 
 class LiteralTokenDeserializationCluster : public DeserializationCluster {
  public:
   LiteralTokenDeserializationCluster() { }
   virtual ~LiteralTokenDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          LiteralToken::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 25 matching lines @@
     RawObject** from = stream->from();
     RawObject** to = stream->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kTokenStreamCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawTokenStream* stream = objects_[i];
       s->AssignRef(stream);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawTokenStream* stream = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class TokenStreamDeserializationCluster : public DeserializationCluster {
  public:
   TokenStreamDeserializationCluster() { }
   virtual ~TokenStreamDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          TokenStream::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 23 matching lines @@
     RawObject** from = script->from();
     RawObject** to = script->to_snapshot(s->kind());
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kScriptCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawScript* script = objects_[i];
       s->AssignRef(script);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 16 matching lines @@
 
 
 class ScriptDeserializationCluster : public DeserializationCluster {
  public:
   ScriptDeserializationCluster() { }
   virtual ~ScriptDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Script::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     Snapshot::Kind kind = d->kind();
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 32 matching lines @@
     RawObject** from = lib->from();
     RawObject** to = lib->to_snapshot();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kLibraryCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawLibrary* lib = objects_[i];
       s->AssignRef(lib);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawLibrary* lib = objects_[i];
@@ skipping 17 matching lines @@
 };
 
 class LibraryDeserializationCluster : public DeserializationCluster {
  public:
   LibraryDeserializationCluster() { }
   virtual ~LibraryDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Library::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ skipping 51 matching lines @@
     RawObject** from = ns->from();
     RawObject** to = ns->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kNamespaceCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawNamespace* ns = objects_[i];
       s->AssignRef(ns);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawNamespace* ns = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class NamespaceDeserializationCluster : public DeserializationCluster {
  public:
   NamespaceDeserializationCluster() { }
   virtual ~NamespaceDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Namespace::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ skipping 22 matching lines @@
     s->Push(code->ptr()->object_pool_);
     s->Push(code->ptr()->owner_);
     s->Push(code->ptr()->exception_handlers_);
     s->Push(code->ptr()->pc_descriptors_);
     s->Push(code->ptr()->stackmaps_);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kCodeCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawCode* code = objects_[i];
       s->AssignRef(code);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 39 matching lines @@
 
 
 class CodeDeserializationCluster : public DeserializationCluster {
  public:
   CodeDeserializationCluster() { }
   virtual ~CodeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Code::InstanceSize(0)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ skipping 54 matching lines @@
         s->Push(pool->ptr()->data()[i].raw_obj_);
       }
     }
 
     // TODO(rmacnak): Allocate the object pool and its info array together.
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kObjectPoolCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawObjectPool* pool = objects_[i];
       intptr_t length = pool->ptr()->length_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(pool);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawObjectPool* pool = objects_[i];
       RawTypedData* info_array = pool->ptr()->info_array_;
       intptr_t length = pool->ptr()->length_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       for (intptr_t j = 0; j < length; j++) {
         ObjectPool::EntryType entry_type =
             static_cast<ObjectPool::EntryType>(info_array->ptr()->data()[j]);
         s->Write<int8_t>(entry_type);
         RawObjectPool::Entry& entry = pool->ptr()->data()[j];
         switch (entry_type) {
           case ObjectPool::kTaggedObject: {
 #if !defined(TARGET_ARCH_DBC)
             if (entry.raw_obj_ ==
                 StubCode::CallNativeCFunction_entry()->code()) {
               // Natives can run while precompiling, becoming linked and
               // switching their stub. Reset to the initial stub used for
               // lazy-linking.
               s->WriteRef(StubCode::CallBootstrapCFunction_entry()->code());
               break;
             }
 #endif
           s->WriteRef(entry.raw_obj_);
           break;
         }
         case ObjectPool::kImmediate: {
-          s->Write<intptr_t>(entry.raw_value_);
+          s->Write<int32_t>(entry.raw_value_);
           break;
         }
         case ObjectPool::kNativeEntry: {
           // Write nothing. Will initialize with the lazy link entry.
 #if defined(TARGET_ARCH_DBC)
           UNREACHABLE();   // DBC does not support lazy native call linking.
 #endif
           break;
         }
         default:
           UNREACHABLE();
         }
       }
     }
   }
 
  private:
   GrowableArray<RawObjectPool*> objects_;
 };
 
 
 class ObjectPoolDeserializationCluster : public DeserializationCluster {
  public:
   ObjectPoolDeserializationCluster() { }
   virtual ~ObjectPoolDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
                                          ObjectPool::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
     PageSpace* old_space = d->heap()->old_space();
     for (intptr_t id = start_index_; id < stop_index_; id += 1) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       RawTypedData* info_array = reinterpret_cast<RawTypedData*>(
           AllocateUninitialized(old_space, TypedData::InstanceSize(length)));
       Deserializer::InitializeHeader(info_array, kTypedDataUint8ArrayCid,
                                      TypedData::InstanceSize(length),
                                      is_vm_object);
       info_array->ptr()->length_ = Smi::New(length);
       RawObjectPool* pool = reinterpret_cast<RawObjectPool*>(d->Ref(id + 0));
       Deserializer::InitializeHeader(pool, kObjectPoolCid,
                                      ObjectPool::InstanceSize(length),
                                      is_vm_object);
       pool->ptr()->length_ = length;
       pool->ptr()->info_array_ = info_array;
       for (intptr_t j = 0; j < length; j++) {
         ObjectPool::EntryType entry_type =
             static_cast<ObjectPool::EntryType>(d->Read<int8_t>());
         info_array->ptr()->data()[j] = entry_type;
         RawObjectPool::Entry& entry = pool->ptr()->data()[j];
         switch (entry_type) {
           case ObjectPool::kTaggedObject:
             entry.raw_obj_ = d->ReadRef();
             break;
           case ObjectPool::kImmediate:
-            entry.raw_value_ = d->Read<intptr_t>();
+            entry.raw_value_ = d->Read<int32_t>();
             break;
           case ObjectPool::kNativeEntry: {
 #if !defined(TARGET_ARCH_DBC)
             // Read nothing. Initialize with the lazy link entry.
             uword new_entry = NativeEntry::LinkNativeCallEntry();
             entry.raw_value_ = static_cast<intptr_t>(new_entry);
 #else
             UNREACHABLE();  // DBC does not support lazy native call linking.
 #endif
             break;
@@ skipping 33 matching lines @@
                                      Smi::Value(str->ptr()->length_) * 2);
         str->ptr()->hash_ = Smi::New(hash);
       }
       ASSERT(str->ptr()->hash_ != Smi::New(0));
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(cid_);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawObject* object = objects_[i];
       int32_t rodata_offset = s->GetRODataOffset(object);
       s->Write<int32_t>(rodata_offset);
       s->AssignRef(object);
     }
   }
 
   void WriteFill(Serializer* s) {
     // No-op.
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawObject*> objects_;
 };
 
 
 class RODataDeserializationCluster : public DeserializationCluster {
  public:
   RODataDeserializationCluster() { }
   virtual ~RODataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       int32_t rodata_offset = d->Read<int32_t>();
       d->AssignRef(d->GetObjectAt(rodata_offset));
     }
   }
 
   void ReadFill(Deserializer* d) {
     // No-op.
   }
 };
@@ skipping 21 matching lines @@
   void Trace(Serializer* s, RawObject* object) {
     RawExceptionHandlers* handlers = ExceptionHandlers::RawCast(object);
     objects_.Add(handlers);
 
     s->Push(handlers->ptr()->handled_types_data_);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kExceptionHandlersCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawExceptionHandlers* handlers = objects_[i];
       intptr_t length = handlers->ptr()->num_entries_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(handlers);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawExceptionHandlers* handlers = objects_[i];
       intptr_t length = handlers->ptr()->num_entries_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->WriteRef(handlers->ptr()->handled_types_data_);
 
       uint8_t* data = reinterpret_cast<uint8_t*>(handlers->ptr()->data());
       intptr_t length_in_bytes =
           length * sizeof(RawExceptionHandlers::HandlerInfo);
       s->WriteBytes(data, length_in_bytes);
     }
   }
 
  private:
   GrowableArray<RawExceptionHandlers*> objects_;
 };
 
 
 class ExceptionHandlersDeserializationCluster : public DeserializationCluster {
  public:
   ExceptionHandlersDeserializationCluster() { }
   virtual ~ExceptionHandlersDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
           ExceptionHandlers::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawExceptionHandlers* handlers =
           reinterpret_cast<RawExceptionHandlers*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       Deserializer::InitializeHeader(handlers, kExceptionHandlersCid,
                                      ExceptionHandlers::InstanceSize(length),
                                      is_vm_object);
       handlers->ptr()->num_entries_ = length;
       handlers->ptr()->handled_types_data_ =
           reinterpret_cast<RawArray*>(d->ReadRef());
 
       uint8_t* data = reinterpret_cast<uint8_t*>(handlers->ptr()->data());
       intptr_t length_in_bytes =
           length * sizeof(RawExceptionHandlers::HandlerInfo);
@@ skipping 14 matching lines @@
     s->Push(context->ptr()->parent_);
     intptr_t length = context->ptr()->num_variables_;
     for (intptr_t i = 0; i < length; i++) {
       s->Push(context->ptr()->data()[i]);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kContextCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawContext* context = objects_[i];
       intptr_t length = context->ptr()->num_variables_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(context);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawContext* context = objects_[i];
       intptr_t length = context->ptr()->num_variables_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->WriteRef(context->ptr()->parent_);
       for (intptr_t j = 0; j < length; j++) {
         s->WriteRef(context->ptr()->data()[j]);
       }
     }
   }
 
  private:
   GrowableArray<RawContext*> objects_;
 };
 
 
 class ContextDeserializationCluster : public DeserializationCluster {
  public:
   ContextDeserializationCluster() { }
   virtual ~ContextDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
                                          Context::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawContext* context = reinterpret_cast<RawContext*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       Deserializer::InitializeHeader(context, kContextCid,
                                      Context::InstanceSize(length),
                                      is_vm_object);
       context->ptr()->num_variables_ = length;
       context->ptr()->parent_ = reinterpret_cast<RawContext*>(d->ReadRef());
       for (intptr_t j = 0; j < length; j++) {
         context->ptr()->data()[j] = d->ReadRef();
       }
     }
   }
@@ skipping 13 matching lines @@
     RawObject** from = scope->from();
     RawObject** to = scope->to(length);
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kContextScopeCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawContextScope* scope = objects_[i];
       intptr_t length = scope->ptr()->num_variables_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(scope);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawContextScope* scope = objects_[i];
       intptr_t length = scope->ptr()->num_variables_;
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->Write<bool>(scope->ptr()->is_implicit_);
       RawObject** from = scope->from();
       RawObject** to = scope->to(length);
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawContextScope*> objects_;
 };
 
 
 class ContextScopeDeserializationCluster : public DeserializationCluster {
  public:
   ContextScopeDeserializationCluster() { }
   virtual ~ContextScopeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
                                          ContextScope::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawContextScope* scope = reinterpret_cast<RawContextScope*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       Deserializer::InitializeHeader(scope, kContextScopeCid,
                                      ContextScope::InstanceSize(length),
                                      is_vm_object);
       scope->ptr()->num_variables_ = length;
       scope->ptr()->is_implicit_ = d->Read<bool>();
       RawObject** from = scope->from();
       RawObject** to = scope->to(length);
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
@@ skipping 14 matching lines @@
     RawObject** from = ic->from();
     RawObject** to = ic->to_snapshot(s->kind());
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kICDataCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawICData* ic = objects_[i];
       s->AssignRef(ic);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawICData* ic = objects_[i];
       RawObject** from = ic->from();
       RawObject** to = ic->to_snapshot(kind);
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
       s->Write<int32_t>(ic->ptr()->deopt_id_);
       s->Write<uint32_t>(ic->ptr()->state_bits_);
 #if defined(TAG_IC_DATA)
-      s->Write<intptr_t>(ic->ptr()->tag_);
+      s->Write<int32_t>(ic->ptr()->tag_);
 #endif
     }
   }
 
  private:
   GrowableArray<RawICData*> objects_;
 };
 
 
 class ICDataDeserializationCluster : public DeserializationCluster {
  public:
   ICDataDeserializationCluster() { }
   virtual ~ICDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, ICData::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     Snapshot::Kind kind = d->kind();
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawICData* ic = reinterpret_cast<RawICData*>(d->Ref(id));
       Deserializer::InitializeHeader(ic, kICDataCid,
                                      ICData::InstanceSize(), is_vm_object);
       RawObject** from = ic->from();
       RawObject** to_snapshot = ic->to_snapshot(kind);
       RawObject** to = ic->to();
       for (RawObject** p = from; p <= to_snapshot; p++) {
         *p = d->ReadRef();
       }
       for (RawObject** p = to_snapshot + 1; p <= to; p++) {
         *p = Object::null();
       }
       ic->ptr()->deopt_id_ = d->Read<int32_t>();
       ic->ptr()->state_bits_ = d->Read<int32_t>();
 #if defined(TAG_IC_DATA)
-      ic->ptr()->tag_ = d->Read<intptr_t>();
+      ic->ptr()->tag_ = d->Read<int32_t>();
 #endif
     }
   }
 
   void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) {
     NOT_IN_PRODUCT(TimelineDurationScope tds(Thread::Current(),
         Timeline::GetIsolateStream(), "PostLoadICData"));
 
     if (kind == Snapshot::kAppNoJIT) {
       ICData& ic = ICData::Handle(zone);
@@ skipping 28 matching lines @@
     RawObject** from = cache->from();
     RawObject** to = cache->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kMegamorphicCacheCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawMegamorphicCache* cache = objects_[i];
       s->AssignRef(cache);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawMegamorphicCache* cache = objects_[i];
@@ skipping 12 matching lines @@
 
 
 class MegamorphicCacheDeserializationCluster : public DeserializationCluster {
  public:
   MegamorphicCacheDeserializationCluster() { }
   virtual ~MegamorphicCacheDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          MegamorphicCache::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 21 matching lines @@
 
   void Trace(Serializer* s, RawObject* object) {
     RawSubtypeTestCache* cache = SubtypeTestCache::RawCast(object);
     objects_.Add(cache);
     s->Push(cache->ptr()->cache_);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kSubtypeTestCacheCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawSubtypeTestCache* cache = objects_[i];
       s->AssignRef(cache);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawSubtypeTestCache* cache = objects_[i];
       s->WriteRef(cache->ptr()->cache_);
     }
   }
 
  private:
   GrowableArray<RawSubtypeTestCache*> objects_;
 };
 
 
 class SubtypeTestCacheDeserializationCluster : public DeserializationCluster {
  public:
   SubtypeTestCacheDeserializationCluster() { }
   virtual ~SubtypeTestCacheDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          SubtypeTestCache::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 21 matching lines @@
     RawObject** from = error->from();
     RawObject** to = error->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kLanguageErrorCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawLanguageError* error = objects_[i];
       s->AssignRef(error);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawLanguageError* error = objects_[i];
@@ skipping 14 matching lines @@
 
 
 class LanguageErrorDeserializationCluster : public DeserializationCluster {
  public:
   LanguageErrorDeserializationCluster() { }
   virtual ~LanguageErrorDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          LanguageError::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 27 matching lines @@
     RawObject** from = exception->from();
     RawObject** to = exception->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kUnhandledExceptionCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawUnhandledException* exception = objects_[i];
       s->AssignRef(exception);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawUnhandledException* exception = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class UnhandledExceptionDeserializationCluster : public DeserializationCluster {
  public:
   UnhandledExceptionDeserializationCluster() { }
   virtual ~UnhandledExceptionDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          UnhandledException::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 10 matching lines @@
       }
     }
   }
 };
 
 
 class InstanceSerializationCluster : public SerializationCluster {
  public:
   explicit InstanceSerializationCluster(intptr_t cid) : cid_(cid) {
     RawClass* cls = Isolate::Current()->class_table()->At(cid);
-    next_field_offset_ =
-        cls->ptr()->next_field_offset_in_words_ << kWordSizeLog2;
+    next_field_offset_in_words_ = cls->ptr()->next_field_offset_in_words_;
     instance_size_in_words_ = cls->ptr()->instance_size_in_words_;
-    ASSERT(next_field_offset_ > 0);
+    ASSERT(next_field_offset_in_words_ > 0);
     ASSERT(instance_size_in_words_ > 0);
   }
   virtual ~InstanceSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawInstance* instance = Instance::RawCast(object);
     objects_.Add(instance);
 
+    intptr_t next_field_offset = next_field_offset_in_words_ << kWordSizeLog2;
     intptr_t offset = Instance::NextFieldOffset();
-    while (offset < next_field_offset_) {
+    while (offset < next_field_offset) {
       RawObject* raw_obj = *reinterpret_cast<RawObject**>(
           reinterpret_cast<uword>(instance->ptr()) + offset);
       s->Push(raw_obj);
       offset += kWordSize;
     }
   }
 
   void WriteAlloc(Serializer* s) {
-    s->Write<intptr_t>(cid_);
+    s->Write<int32_t>(cid_);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
 
-    s->Write<intptr_t>(next_field_offset_);
-    s->Write<intptr_t>(instance_size_in_words_);
+    s->Write<int32_t>(next_field_offset_in_words_);
+    s->Write<int32_t>(instance_size_in_words_);
 
     for (intptr_t i = 0; i < count; i++) {
       RawInstance* instance = objects_[i];
       s->AssignRef(instance);
     }
   }
 
   void WriteFill(Serializer* s) {
+    intptr_t next_field_offset = next_field_offset_in_words_ << kWordSizeLog2;
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawInstance* instance = objects_[i];
       s->Write<bool>(instance->IsCanonical());
       intptr_t offset = Instance::NextFieldOffset();
-      while (offset < next_field_offset_) {
+      while (offset < next_field_offset) {
         RawObject* raw_obj = *reinterpret_cast<RawObject**>(
             reinterpret_cast<uword>(instance->ptr()) + offset);
         s->WriteRef(raw_obj);
         offset += kWordSize;
       }
     }
   }
 
  private:
   const intptr_t cid_;
-  intptr_t next_field_offset_;
+  intptr_t next_field_offset_in_words_;
   intptr_t instance_size_in_words_;
   GrowableArray<RawInstance*> objects_;
 };
 
 
 class InstanceDeserializationCluster : public DeserializationCluster {
  public:
   explicit InstanceDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~InstanceDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
-    next_field_offset_  = d->Read<intptr_t>();
-    instance_size_in_words_  = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
+    next_field_offset_in_words_ = d->Read<int32_t>();
+    instance_size_in_words_ = d->Read<int32_t>();
     intptr_t instance_size =
         Object::RoundedAllocationSize(instance_size_in_words_ * kWordSize);
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, instance_size));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
+    intptr_t next_field_offset = next_field_offset_in_words_ << kWordSizeLog2;
     intptr_t instance_size =
         Object::RoundedAllocationSize(instance_size_in_words_ * kWordSize);
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawInstance* instance = reinterpret_cast<RawInstance*>(d->Ref(id));
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(instance, cid_,
                                      instance_size,
                                      is_vm_object, is_canonical);
       intptr_t offset = Instance::NextFieldOffset();
-      while (offset < next_field_offset_) {
+      while (offset < next_field_offset) {
         RawObject** p = reinterpret_cast<RawObject**>(
             reinterpret_cast<uword>(instance->ptr()) + offset);
         *p = d->ReadRef();
         offset += kWordSize;
       }
       if (offset < instance_size) {
         RawObject** p = reinterpret_cast<RawObject**>(
             reinterpret_cast<uword>(instance->ptr()) + offset);
         *p = Object::null();
         offset += kWordSize;
       }
       ASSERT(offset == instance_size);
     }
   }
 
  private:
   const intptr_t cid_;
-  intptr_t next_field_offset_;
+  intptr_t next_field_offset_in_words_;
   intptr_t instance_size_in_words_;
 };
 
 
 class LibraryPrefixSerializationCluster : public SerializationCluster {
  public:
   LibraryPrefixSerializationCluster() { }
   virtual ~LibraryPrefixSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawLibraryPrefix* prefix = LibraryPrefix::RawCast(object);
     objects_.Add(prefix);
 
     RawObject** from = prefix->from();
     RawObject** to = prefix->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kLibraryPrefixCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawLibraryPrefix* prefix = objects_[i];
       s->AssignRef(prefix);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawLibraryPrefix* prefix = objects_[i];
@@ skipping 14 matching lines @@
 
 
 class LibraryPrefixDeserializationCluster : public DeserializationCluster {
  public:
   LibraryPrefixDeserializationCluster() { }
   virtual ~LibraryPrefixDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          LibraryPrefix::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 37 matching lines @@
 
     RawSmi* raw_type_class_id = Smi::RawCast(type->ptr()->type_class_id_);
     RawClass* type_class =
         s->isolate()->class_table()->At(Smi::Value(raw_type_class_id));
     s->Push(type_class);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kTypeCid);
     intptr_t count = canonical_objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawType* type = canonical_objects_[i];
       s->AssignRef(type);
     }
     count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawType* type = objects_[i];
       s->AssignRef(type);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = canonical_objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawType* type = canonical_objects_[i];
@@ skipping 25 matching lines @@
 
 
 class TypeDeserializationCluster : public DeserializationCluster {
  public:
   TypeDeserializationCluster() { }
   virtual ~TypeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     canonical_start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Type::InstanceSize()));
     }
     canonical_stop_index_ = d->next_index();
 
     start_index_ = d->next_index();
-    count = d->Read<intptr_t>();
+    count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Type::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = canonical_start_index_;
@@ skipping 43 matching lines @@
     RawObject** from = type->from();
     RawObject** to = type->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kTypeRefCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawTypeRef* type = objects_[i];
       s->AssignRef(type);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawTypeRef* type = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class TypeRefDeserializationCluster : public DeserializationCluster {
  public:
   TypeRefDeserializationCluster() { }
   virtual ~TypeRefDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, TypeRef::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ skipping 23 matching lines @@
     RawObject** from = type->from();
     RawObject** to = type->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kTypeParameterCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawTypeParameter* type = objects_[i];
       s->AssignRef(type);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawTypeParameter* type = objects_[i];
       RawObject** from = type->from();
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
-      s->Write<intptr_t>(type->ptr()->parameterized_class_id_);
+      s->Write<int32_t>(type->ptr()->parameterized_class_id_);
       s->WriteTokenPosition(type->ptr()->token_pos_);
       s->Write<int16_t>(type->ptr()->index_);
       s->Write<int8_t>(type->ptr()->type_state_);
     }
   }
 
  private:
   GrowableArray<RawTypeParameter*> objects_;
 };
 
 
 class TypeParameterDeserializationCluster : public DeserializationCluster {
  public:
   TypeParameterDeserializationCluster() { }
   virtual ~TypeParameterDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          TypeParameter::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawTypeParameter* type = reinterpret_cast<RawTypeParameter*>(d->Ref(id));
       Deserializer::InitializeHeader(type, kTypeParameterCid,
                                      TypeParameter::InstanceSize(),
                                      is_vm_object);
       RawObject** from = type->from();
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
-      type->ptr()->parameterized_class_id_ = d->Read<intptr_t>();
+      type->ptr()->parameterized_class_id_ = d->Read<int32_t>();
       type->ptr()->token_pos_ = d->ReadTokenPosition();
       type->ptr()->index_ = d->Read<int16_t>();
       type->ptr()->type_state_ = d->Read<int8_t>();
     }
   }
 };
 
 
 class BoundedTypeSerializationCluster : public SerializationCluster {
  public:
   BoundedTypeSerializationCluster() { }
   virtual ~BoundedTypeSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawBoundedType* type = BoundedType::RawCast(object);
     objects_.Add(type);
 
     RawObject** from = type->from();
     RawObject** to = type->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kBoundedTypeCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawBoundedType* type = objects_[i];
       s->AssignRef(type);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawBoundedType* type = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class BoundedTypeDeserializationCluster : public DeserializationCluster {
  public:
   BoundedTypeDeserializationCluster() { }
   virtual ~BoundedTypeDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          BoundedType::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 23 matching lines @@
     RawObject** from = closure->from();
     RawObject** to = closure->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kClosureCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawClosure* closure = objects_[i];
       s->AssignRef(closure);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawClosure* closure = objects_[i];
@@ skipping 12 matching lines @@
 
 
 class ClosureDeserializationCluster : public DeserializationCluster {
  public:
   ClosureDeserializationCluster() { }
   virtual ~ClosureDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Closure::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawClosure* closure = reinterpret_cast<RawClosure*>(d->Ref(id));
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(closure, kClosureCid,
                                      Closure::InstanceSize(),
                                      is_vm_object, is_canonical);
       RawObject** from = closure->from();
       RawObject** to = closure->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
 
+bool IsAlwaysSmi(int64_t value) {
+  const int64_t kMaxInt31 = (static_cast<int64_t>(1) << 30) - 1;
+  const int64_t kMinInt31 = -(static_cast<int64_t>(1) << 30);
+  return (value <= kMaxInt31) && (value >= kMinInt31);
+}
+
+
+bool IsAlwaysMint(int64_t value) {
+  const int64_t kMaxInt63 = (static_cast<int64_t>(1) << 62) - 1;
+  const int64_t kMinInt63 = -(static_cast<int64_t>(1) << 62);
+  return (value > kMaxInt63) || (value < kMinInt63);
+}
+
+
 class MintSerializationCluster : public SerializationCluster {
  public:
   MintSerializationCluster() { }
   virtual ~MintSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
-    RawMint* mint = Mint::RawCast(object);
-    objects_.Add(mint);
+    if (!object->IsHeapObject()) {
+      RawSmi* smi = Smi::RawCast(object);
+      if (IsAlwaysSmi(Smi::Value(smi))) {
+        always_smi_.Add(smi);
+      } else {
+        sometimes_smi_.Add(smi);
+      }
+    } else {
+      RawMint* mint = Mint::RawCast(object);
+      if (IsAlwaysMint(mint->ptr()->value_)) {
+        always_mint_.Add(mint);
+      } else {
+        sometimes_mint_.Add(mint);
+      }
+    }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kMintCid);
-    intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
-    for (intptr_t i = 0; i < count; i++) {
-      RawMint* mint = objects_[i];
-      s->AssignRef(mint);
+
+    {
+      intptr_t count = always_smi_.length();
+      s->Write<int32_t>(count);
+      for (intptr_t i = 0; i < count; i++) {
+        RawSmi* smi = always_smi_[i];
+        s->Write<int32_t>(Smi::Value(smi));
+        s->AssignRef(smi);
+      }
+    }
+
+    {
+      s->Write<int32_t>(sometimes_smi_.length() + sometimes_mint_.length());
+      for (intptr_t i = 0; i < sometimes_smi_.length(); i++) {
+        RawSmi* smi = sometimes_smi_[i];
+        s->Write<int64_t>(Smi::Value(smi));
+        s->AssignRef(smi);
+      }
+
+      for (intptr_t i = 0; i < sometimes_mint_.length(); i++) {
+        RawMint* mint = sometimes_mint_[i];
+        s->Write<int64_t>(mint->ptr()->value_);
+        s->AssignRef(mint);
+      }
+    }
+
+    {
+      intptr_t count = always_mint_.length();
+      s->Write<int32_t>(count);
+      for (intptr_t i = 0; i < count; i++) {
+        RawMint* mint = always_mint_[i];
+        s->Write<int64_t>(mint->ptr()->value_);
+        s->AssignRef(mint);
+      }
     }

[siva, 2016/07/08 16:25:20]

I am not sure I understand the benefit of classifying these into these 3
categories instead of just writing them out always as int64_t values and
always treating Mints that get created on the other side as always being
canonical and create the objects using Mint::NewCanonical(value).

[rmacnak, 2016/07/08 18:08:58]

It is not safe to run Mint::NewCanonical during ReadAlloc. In particular, the
mint canonical table hasn't been allocated yet.

   }
 
-  void WriteFill(Serializer* s) {
-    intptr_t count = objects_.length();
-    for (intptr_t i = 0; i < count; i++) {
-      RawMint* mint = objects_[i];
-      s->Write<bool>(mint->IsCanonical());
-      s->Write<int64_t>(mint->ptr()->value_);
-    }
-  }
+  void WriteFill(Serializer* s) { }

[siva, 2016/07/08 16:25:20]

How is the canonical property of the always_mint objects carried over?

[rmacnak, 2016/07/08 18:08:58]

Every encountered mint is canonical.

 
  private:
-  GrowableArray<RawMint*> objects_;
+  GrowableArray<RawSmi*> always_smi_;
+  GrowableArray<RawSmi*> sometimes_smi_;
+  GrowableArray<RawMint*> sometimes_mint_;
+  GrowableArray<RawMint*> always_mint_;
 };
 
 
 class MintDeserializationCluster : public DeserializationCluster {
  public:
   MintDeserializationCluster() { }
   virtual ~MintDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
-    start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    bool is_vm_object = d->isolate() == Dart::vm_isolate();
+
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      d->AssignRef(AllocateUninitialized(old_space, Mint::InstanceSize()));
+      d->AssignRef(Smi::New(d->Read<int32_t>()));
     }
-    stop_index_ = d->next_index();
+
+    count = d->Read<int32_t>();
+    for (intptr_t i = 0; i < count; i++) {
+#if defined(ARCH_IS_64_BIT)
+      d->AssignRef(Smi::New(d->Read<int64_t>()));
+#else
+      RawMint* mint = static_cast<RawMint*>(
+          AllocateUninitialized(old_space, Mint::InstanceSize()));
+      Deserializer::InitializeHeader(mint, kMintCid,
+                                     Mint::InstanceSize(),
+                                     is_vm_object, true);
+      mint->ptr()->value_ = d->Read<int64_t>();
+      d->AssignRef(mint);
+#endif

[siva, 2016/07/08 16:25:20]

Would prefer if you did 
int64_t value = d->Read<int64_t>();
if (Smi::IsValid(value) {
  ...
} else {
  ...
  ...
}

instead of the #if defined ....

[rmacnak, 2016/07/08 20:17:54]

Done.

+    }
+
+    count = d->Read<int32_t>();
+    for (intptr_t i = 0; i < count; i++) {
+      RawMint* mint = static_cast<RawMint*>(
+          AllocateUninitialized(old_space, Mint::InstanceSize()));
+      Deserializer::InitializeHeader(mint, kMintCid,
+                                     Mint::InstanceSize(),
+                                     is_vm_object, true);
+      mint->ptr()->value_ = d->Read<int64_t>();
+      d->AssignRef(mint);
+    }
   }
 
-  void ReadFill(Deserializer* d) {
-    bool is_vm_object = d->isolate() == Dart::vm_isolate();
+  void ReadFill(Deserializer* d) { }
 
-    for (intptr_t id = start_index_; id < stop_index_; id++) {
-      RawMint* mint = reinterpret_cast<RawMint*>(d->Ref(id));
-      bool is_canonical = d->Read<bool>();
-      Deserializer::InitializeHeader(mint, kMintCid,
-                                     Mint::InstanceSize(),
-                                     is_vm_object, is_canonical);
-      mint->ptr()->value_ = d->Read<int64_t>();
-    }
+  void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) {
+    // TODO(rmacnak): Fix the Mint class's constants.
   }
 };
 
 
 class BigintSerializationCluster : public SerializationCluster {
  public:
   BigintSerializationCluster() { }
   virtual ~BigintSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawBigint* bigint = Bigint::RawCast(object);
     objects_.Add(bigint);
 
     RawObject** from = bigint->from();
     RawObject** to = bigint->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kBigintCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawBigint* bigint = objects_[i];
       s->AssignRef(bigint);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawBigint* bigint = objects_[i];
@@ skipping 12 matching lines @@
 
 
 class BigintDeserializationCluster : public DeserializationCluster {
  public:
   BigintDeserializationCluster() { }
   virtual ~BigintDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Bigint::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ skipping 18 matching lines @@
   virtual ~DoubleSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawDouble* dbl = Double::RawCast(object);
     objects_.Add(dbl);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kDoubleCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawDouble* dbl = objects_[i];
       s->AssignRef(dbl);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawDouble* dbl = objects_[i];
       s->Write<bool>(dbl->IsCanonical());
       s->Write<double>(dbl->ptr()->value_);
     }
   }
 
  private:
   GrowableArray<RawDouble*> objects_;
 };
 
 
 class DoubleDeserializationCluster : public DeserializationCluster {
  public:
   DoubleDeserializationCluster() { }
   virtual ~DoubleDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Double::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
@@ skipping 20 matching lines @@
     RawObject** from = array->from();
     RawObject** to = array->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kGrowableObjectArrayCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawGrowableObjectArray* array = objects_[i];
       s->AssignRef(array);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawGrowableObjectArray* array = objects_[i];
@@ skipping 13 matching lines @@
 
 class GrowableObjectArrayDeserializationCluster
     : public DeserializationCluster {
  public:
   GrowableObjectArrayDeserializationCluster() { }
   virtual ~GrowableObjectArrayDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          GrowableObjectArray::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 18 matching lines @@
  public:
   explicit TypedDataSerializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~TypedDataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypedData* data = TypedData::RawCast(object);
     objects_.Add(data);
   }
 
   void WriteAlloc(Serializer* s) {
-    s->Write<intptr_t>(cid_);
+    s->Write<int32_t>(cid_);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawTypedData* data = objects_[i];
       intptr_t length = Smi::Value(data->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(data);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     intptr_t element_size = TypedData::ElementSizeInBytes(cid_);
     for (intptr_t i = 0; i < count; i++) {
       RawTypedData* data = objects_[i];
       intptr_t length = Smi::Value(data->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->Write<bool>(data->IsCanonical());
       uint8_t* cdata = reinterpret_cast<uint8_t*>(data->ptr()->data());
       s->WriteBytes(cdata, length * element_size);
     }
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawTypedData*> objects_;
 };
 
 
 class TypedDataDeserializationCluster : public DeserializationCluster {
  public:
   explicit TypedDataDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~TypedDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     intptr_t element_size = TypedData::ElementSizeInBytes(cid_);
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
           TypedData::InstanceSize(length * element_size)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
     intptr_t element_size = TypedData::ElementSizeInBytes(cid_);
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawTypedData* data = reinterpret_cast<RawTypedData*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       bool is_canonical = d->Read<bool>();
       intptr_t length_in_bytes = length * element_size;
       Deserializer::InitializeHeader(data, cid_,
                                      TypedData::InstanceSize(length_in_bytes),
                                      is_vm_object, is_canonical);
       data->ptr()->length_ = Smi::New(length);
       uint8_t* cdata = reinterpret_cast<uint8_t*>(data->ptr()->data());
       d->ReadBytes(cdata, length_in_bytes);
     }
   }
 
  private:
   const intptr_t cid_;
 };
 
 
 class ExternalTypedDataSerializationCluster : public SerializationCluster {
  public:
   explicit ExternalTypedDataSerializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~ExternalTypedDataSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawExternalTypedData* data = ExternalTypedData::RawCast(object);
     objects_.Add(data);
     ASSERT(!data->IsCanonical());
   }
 
   void WriteAlloc(Serializer* s) {
-    s->Write<intptr_t>(cid_);
+    s->Write<int32_t>(cid_);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawExternalTypedData* data = objects_[i];
       s->AssignRef(data);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     intptr_t element_size = ExternalTypedData::ElementSizeInBytes(cid_);
     for (intptr_t i = 0; i < count; i++) {
       RawExternalTypedData* data = objects_[i];
       intptr_t length = Smi::Value(data->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       uint8_t* cdata = reinterpret_cast<uint8_t*>(data->ptr()->data_);
       s->WriteBytes(cdata, length * element_size);
     }
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawExternalTypedData*> objects_;
 };
 
 
 class ExternalTypedDataDeserializationCluster : public DeserializationCluster {
  public:
   explicit ExternalTypedDataDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~ExternalTypedDataDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          ExternalTypedData::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
     intptr_t element_size = ExternalTypedData::ElementSizeInBytes(cid_);
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawExternalTypedData* data =
           reinterpret_cast<RawExternalTypedData*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       Deserializer::InitializeHeader(data, cid_,
                                      ExternalTypedData::InstanceSize(),
                                      is_vm_object);
       data->ptr()->length_ = Smi::New(length);
       data->ptr()->data_ = const_cast<uint8_t*>(d->CurrentBufferAddress());
       d->Advance(length * element_size);
     }
   }
 
  private:
@@ skipping 13 matching lines @@
     RawObject** from = trace->from();
     RawObject** to = trace->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kStacktraceCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawStacktrace* trace = objects_[i];
       s->AssignRef(trace);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawStacktrace* trace = objects_[i];
@@ skipping 11 matching lines @@
 
 
 class StacktraceDeserializationCluster : public DeserializationCluster {
  public:
   StacktraceDeserializationCluster() { }
   virtual ~StacktraceDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          Stacktrace::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
@@ skipping 23 matching lines @@
     RawObject** from = regexp->from();
     RawObject** to = regexp->to();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kRegExpCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawRegExp* regexp = objects_[i];
       s->AssignRef(regexp);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawRegExp* regexp = objects_[i];
       RawObject** from = regexp->from();
       RawObject** to = regexp->to();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
 
-      s->Write<intptr_t>(regexp->ptr()->num_registers_);
+      s->Write<int32_t>(regexp->ptr()->num_registers_);
       s->Write<int8_t>(regexp->ptr()->type_flags_);
     }
   }
 
  private:
   GrowableArray<RawRegExp*> objects_;
 };
 
 
 class RegExpDeserializationCluster : public DeserializationCluster {
  public:
   RegExpDeserializationCluster() { }
   virtual ~RegExpDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          RegExp::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawRegExp* regexp = reinterpret_cast<RawRegExp*>(d->Ref(id));
       Deserializer::InitializeHeader(regexp, kRegExpCid,
                                      RegExp::InstanceSize(), is_vm_object);
       RawObject** from = regexp->from();
       RawObject** to = regexp->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
 
-      regexp->ptr()->num_registers_ = d->Read<intptr_t>();
+      regexp->ptr()->num_registers_ = d->Read<int32_t>();
       regexp->ptr()->type_flags_ = d->Read<int8_t>();
     }
   }
 };
 
 
 class LinkedHashMapSerializationCluster : public SerializationCluster {
  public:
   LinkedHashMapSerializationCluster() { }
   virtual ~LinkedHashMapSerializationCluster() { }
@@ skipping 13 matching lines @@
         RawObject* value = data_elements[i + 1];
         s->Push(key);
         s->Push(value);
       }
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kLinkedHashMapCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawLinkedHashMap* map = objects_[i];
       s->AssignRef(map);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawLinkedHashMap* map = objects_[i];
       s->Write<bool>(map->IsCanonical());
 
       s->WriteRef(map->ptr()->type_arguments_);
 
       const intptr_t used_data = Smi::Value(map->ptr()->used_data_);
       ASSERT((used_data & 1) == 0);  // Keys + values, so must be even.
       const intptr_t deleted_keys = Smi::Value(map->ptr()->deleted_keys_);
 
       // Write out the number of (not deleted) key/value pairs that will follow.
-      s->Write<intptr_t>((used_data >> 1) - deleted_keys);
+      s->Write<int32_t>((used_data >> 1) - deleted_keys);
 
       RawArray* data_array = map->ptr()->data_;
       RawObject** data_elements = data_array->ptr()->data();
       for (intptr_t i = 0; i < used_data; i += 2) {
         RawObject* key = data_elements[i];
         if (key != data_array) {
           RawObject* value = data_elements[i + 1];
           s->WriteRef(key);
           s->WriteRef(value);
         }
       }
     }
   }
 
  private:
   GrowableArray<RawLinkedHashMap*> objects_;
 };
 
 
 class LinkedHashMapDeserializationCluster : public DeserializationCluster {
  public:
   LinkedHashMapDeserializationCluster() { }
   virtual ~LinkedHashMapDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space,
                                          LinkedHashMap::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
     PageSpace* old_space = d->heap()->old_space();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawLinkedHashMap* map = reinterpret_cast<RawLinkedHashMap*>(d->Ref(id));
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(map, kLinkedHashMapCid,
                                      LinkedHashMap::InstanceSize(),
                                      is_vm_object, is_canonical);
 
       map->ptr()->type_arguments_ =
           reinterpret_cast<RawTypeArguments*>(d->ReadRef());
 
       // TODO(rmacnak): Reserve ref ids and co-allocate in ReadAlloc.
-      intptr_t pairs = d->Read<intptr_t>();
+      intptr_t pairs = d->Read<int32_t>();
       intptr_t used_data = pairs << 1;
       intptr_t data_size = Utils::Maximum(
           Utils::RoundUpToPowerOfTwo(used_data),
           static_cast<uintptr_t>(LinkedHashMap::kInitialIndexSize));
 
       RawArray* data = reinterpret_cast<RawArray*>(
           AllocateUninitialized(old_space, Array::InstanceSize(data_size)));
       data->ptr()->type_arguments_ = TypeArguments::null();
       data->ptr()->length_ = Smi::New(data_size);
       intptr_t i;
@@ skipping 26 matching lines @@
     s->Push(array->ptr()->type_arguments_);
     intptr_t length = Smi::Value(array->ptr()->length_);
     for (intptr_t i = 0; i < length; i++) {
       s->Push(array->ptr()->data()[i]);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(cid_);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawArray* array = objects_[i];
       intptr_t length = Smi::Value(array->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(array);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawArray* array = objects_[i];
       intptr_t length = Smi::Value(array->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->Write<bool>(array->IsCanonical());
       s->WriteRef(array->ptr()->type_arguments_);
       for (intptr_t j = 0; j < length; j++) {
         s->WriteRef(array->ptr()->data()[j]);
       }
     }
   }
 
  private:
   intptr_t cid_;
   GrowableArray<RawArray*> objects_;
 };
 
 
 class ArrayDeserializationCluster : public DeserializationCluster {
  public:
   explicit ArrayDeserializationCluster(intptr_t cid) : cid_(cid) { }
   virtual ~ArrayDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
                                          Array::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawArray* array = reinterpret_cast<RawArray*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(array, cid_,
                                      Array::InstanceSize(length),
                                      is_vm_object, is_canonical);
       array->ptr()->type_arguments_ =
           reinterpret_cast<RawTypeArguments*>(d->ReadRef());
       array->ptr()->length_ = Smi::New(length);
       for (intptr_t j = 0; j < length; j++) {
         array->ptr()->data()[j] = d->ReadRef();
       }
@@ skipping 11 matching lines @@
   virtual ~OneByteStringSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawOneByteString* str = reinterpret_cast<RawOneByteString*>(object);
     objects_.Add(str);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kOneByteStringCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawOneByteString* str = objects_[i];
       intptr_t length = Smi::Value(str->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(str);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawOneByteString* str = objects_[i];
       intptr_t length = Smi::Value(str->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->Write<bool>(str->IsCanonical());
       intptr_t hash = Smi::Value(str->ptr()->hash_);
       s->Write<int32_t>(hash);
       s->WriteBytes(str->ptr()->data(), length);
     }
   }
 
  private:
   GrowableArray<RawOneByteString*> objects_;
 };
 
 
 class OneByteStringDeserializationCluster : public DeserializationCluster {
  public:
   OneByteStringDeserializationCluster() { }
   virtual ~OneByteStringDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
                                          OneByteString::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawOneByteString* str = reinterpret_cast<RawOneByteString*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(str, kOneByteStringCid,
                                      OneByteString::InstanceSize(length),
                                      is_vm_object, is_canonical);
       str->ptr()->length_ = Smi::New(length);
-      str->ptr()->hash_ = Smi::New(d->Read<intptr_t>());
+      str->ptr()->hash_ = Smi::New(d->Read<int32_t>());
       for (intptr_t j = 0; j < length; j++) {
         str->ptr()->data()[j] = d->Read<uint8_t>();
       }
     }
   }
 };
 
 
 class TwoByteStringSerializationCluster : public SerializationCluster {
  public:
   TwoByteStringSerializationCluster() { }
   virtual ~TwoByteStringSerializationCluster() { }
 
   void Trace(Serializer* s, RawObject* object) {
     RawTwoByteString* str = reinterpret_cast<RawTwoByteString*>(object);
     objects_.Add(str);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kTwoByteStringCid);
     intptr_t count = objects_.length();
-    s->Write<intptr_t>(count);
+    s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawTwoByteString* str = objects_[i];
       intptr_t length = Smi::Value(str->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->AssignRef(str);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawTwoByteString* str = objects_[i];
       intptr_t length = Smi::Value(str->ptr()->length_);
-      s->Write<intptr_t>(length);
+      s->Write<int32_t>(length);
       s->Write<bool>(str->IsCanonical());
       intptr_t hash = Smi::Value(str->ptr()->hash_);
       s->Write<int32_t>(hash);
       s->WriteBytes(reinterpret_cast<uint8_t*>(str->ptr()->data()), length * 2);
     }
   }
 
  private:
   GrowableArray<RawTwoByteString*> objects_;
 };
 
 
 class TwoByteStringDeserializationCluster : public DeserializationCluster {
  public:
   TwoByteStringDeserializationCluster() { }
   virtual ~TwoByteStringDeserializationCluster() { }
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
-    intptr_t count = d->Read<intptr_t>();
+    intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       d->AssignRef(AllocateUninitialized(old_space,
                                          TwoByteString::InstanceSize(length)));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawTwoByteString* str =
           reinterpret_cast<RawTwoByteString*>(d->Ref(id));
-      intptr_t length = d->Read<intptr_t>();
+      intptr_t length = d->Read<int32_t>();
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(str, kTwoByteStringCid,
                                      TwoByteString::InstanceSize(length),
                                      is_vm_object, is_canonical);
       str->ptr()->length_ = Smi::New(length);
       str->ptr()->hash_ = Smi::New(d->Read<int32_t>());
       uint8_t* cdata = reinterpret_cast<uint8_t*>(str->ptr()->data());
       d->ReadBytes(cdata, length * 2);
     }
   }
@@ skipping 117 matching lines @@
   }
 
   FATAL1("No cluster defined for cid %" Pd, cid);
   return NULL;
 }
 
 
 void Serializer::Trace(RawObject* object) {
   intptr_t cid;
   if (!object->IsHeapObject()) {
-    cid = kSmiCid;
+    // Smis are merged into the Mint cluster because Smis for the writer might
+    // become Mints for the reader and vice versa.
+    cid = kMintCid;
   } else {
     cid = object->GetClassId();
   }
 
   SerializationCluster* cluster = clusters_by_cid_[cid];
   if (cluster == NULL) {
     cluster = NewClusterForClass(cid);
     clusters_by_cid_[cid] = cluster;
   }
   ASSERT(cluster != NULL);
@@ skipping 10 matching lines @@
   const char* expected_features = Dart::FeaturesString(kind_);
   ASSERT(expected_features != NULL);
   const intptr_t features_len = strlen(expected_features);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_features),
              features_len + 1);
   free(const_cast<char*>(expected_features));
 }
 
 
 #if defined(DEBUG)
-static const intptr_t kSectionMarker = 0xABAB;
+static const int32_t kSectionMarker = 0xABAB;
 #endif
 
 void Serializer::Serialize() {
   while (stack_.length() > 0) {
     Trace(stack_.RemoveLast());
   }
 
   intptr_t num_clusters = 0;
   for (intptr_t cid = 1; cid < num_cids_; cid++) {
     SerializationCluster* cluster = clusters_by_cid_[cid];
     if (cluster != NULL) {
       num_clusters++;
     }
   }
 
   intptr_t num_objects = num_base_objects_ + num_written_objects_;
 
   Write<int32_t>(num_objects);
   Write<int32_t>(num_clusters);
 
   for (intptr_t cid = 1; cid < num_cids_; cid++) {
     SerializationCluster* cluster = clusters_by_cid_[cid];
     if (cluster != NULL) {
       cluster->WriteAlloc(this);
 #if defined(DEBUG)
-      Write<intptr_t>(next_ref_index_);
+      Write<int32_t>(next_ref_index_);
 #endif
     }
   }
 
   // We should have assigned a ref to every object we pushed.
   ASSERT((next_ref_index_ - 1) == num_objects);
 
   for (intptr_t cid = 1; cid < num_cids_; cid++) {
     SerializationCluster* cluster = clusters_by_cid_[cid];
     if (cluster != NULL) {
       cluster->WriteFill(this);
 #if defined(DEBUG)
-      Write<intptr_t>(kSectionMarker);
+      Write<int32_t>(kSectionMarker);
 #endif
     }
   }
 }
 
 
 void Serializer::AddVMIsolateBaseObjects() {
   // These objects are always allocated by Object::InitOnce, so they are not
   // written into the snapshot.
 
@@ skipping 49 matching lines @@
   Serialize();
 
   // Write roots.
   WriteRef(symbols.raw());
   WriteRef(scripts.raw());
   if (Snapshot::IncludesCode(kind_)) {
     StubCode::WriteRef(this);
   }
 
 #if defined(DEBUG)
-  Write<intptr_t>(kSectionMarker);
+  Write<int32_t>(kSectionMarker);
 #endif
 
   // Note we are not clearing the object id table. The full ref table
   // of the vm isolate snapshot serves as the base objects for the
   // regular isolate snapshot.
 
   // Return the number of objects, -1 accounts for unused ref 0.
   return next_ref_index_ - 1;
 }
 
@@ skipping 22 matching lines @@
   }
 
   Serialize();
 
   // Write roots.
   for (RawObject** p = from; p <= to; p++) {
     WriteRef(*p);
   }
 
 #if defined(DEBUG)
-  Write<intptr_t>(kSectionMarker);
+  Write<int32_t>(kSectionMarker);
 #endif
 
   heap_->ResetObjectIdTable();
 }
 
 
 Deserializer::Deserializer(Thread* thread,
                            Snapshot::Kind kind,
                            const uint8_t* buffer,
                            intptr_t size,
@@ skipping 199 matching lines @@
 void Deserializer::Deserialize() {
   // TODO(rmacnak): Verify num of base objects.
 
   {
     NOT_IN_PRODUCT(TimelineDurationScope tds(thread(),
         Timeline::GetIsolateStream(), "ReadAlloc"));
     for (intptr_t i = 0; i < num_clusters_; i++) {
       clusters_[i] = ReadCluster();
       clusters_[i]->ReadAlloc(this);
 #if defined(DEBUG)
-      intptr_t serializers_next_ref_index_ = Read<intptr_t>();
+      intptr_t serializers_next_ref_index_ = Read<int32_t>();
       ASSERT(serializers_next_ref_index_ == next_ref_index_);
 #endif
     }
   }
 
   // We should have completely filled the ref array.
   ASSERT((next_ref_index_ - 1) == num_objects_);
 
   {
     NOT_IN_PRODUCT(TimelineDurationScope tds(thread(),
         Timeline::GetIsolateStream(), "ReadFill"));
     for (intptr_t i = 0; i < num_clusters_; i++) {
       clusters_[i]->ReadFill(this);
 #if defined(DEBUG)
-      intptr_t section_marker = Read<intptr_t>();
+      int32_t section_marker = Read<int32_t>();
       ASSERT(section_marker == kSectionMarker);
 #endif
     }
   }
 }
 
 class HeapLocker : public StackResource {
  public:
   HeapLocker(Thread* thread, PageSpace* page_space)
       : StackResource(thread), page_space_(page_space) {
@@ skipping 63 matching lines @@
 
     // Read roots.
     symbol_table ^= ReadRef();
     isolate()->object_store()->set_symbol_table(symbol_table);
     ReadRef();  // Script list.
     if (Snapshot::IncludesCode(kind_)) {
       StubCode::ReadRef(this);
     }
 
 #if defined(DEBUG)
-    intptr_t section_marker = Read<intptr_t>();
+    int32_t section_marker = Read<int32_t>();
     ASSERT(section_marker == kSectionMarker);
 #endif
 
     refs = refs_;
     refs_ = NULL;
   }
 
   Symbols::InitOnceFromSnapshot(isolate());
 
   Object::set_vm_isolate_snapshot_object_table(refs);
@@ skipping 20 matching lines @@
     Deserialize();
 
     // Read roots.
     RawObject** from = object_store->from();
     RawObject** to = object_store->to_snapshot(kind_);
     for (RawObject** p = from; p <= to; p++) {
       *p = ReadRef();
     }
 
 #if defined(DEBUG)
-    intptr_t section_marker = Read<intptr_t>();
+    int32_t section_marker = Read<int32_t>();
     ASSERT(section_marker == kSectionMarker);
 #endif
 
     refs = refs_;
     refs_ = NULL;
   }
 
 #if defined(DEBUG)
   Isolate* isolate = thread()->isolate();
   isolate->ValidateClassTable();
@@ skipping 236 matching lines @@
 
   deserializer.ReadVMSnapshot();
 
   Dart::set_instructions_snapshot_buffer(instructions_buffer_);
   Dart::set_data_snapshot_buffer(data_buffer_);
 
   return ApiError::null();
 }
 
 }  // namespace dart