Make snapshots 32 or 64 bit compliant by using Write<int64_t> and Read<int64_t> for intptr_t type...

vm/raw_object_snapshot.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
@@ skipping 24 matching lines @@
     ObjectKind kind = reader->Read<ObjectKind>();
 
     // Allocate class object of specified kind.
     cls = Class::GetClass(kind);
     reader->AddBackwardReference(object_id, &cls);
 
     // Set the object tags.
     cls.set_tags(tags);
 
     // Set all non object fields.
-    cls.set_instance_size(reader->Read<intptr_t>());
-    cls.set_type_arguments_instance_field_offset(reader->Read<intptr_t>());
-    cls.set_next_field_offset(reader->Read<intptr_t>());
-    cls.set_num_native_fields(reader->Read<intptr_t>());
+    cls.set_instance_size(reader->ReadIntptrValue());
+    cls.set_type_arguments_instance_field_offset(reader->ReadIntptrValue());
+    cls.set_next_field_offset(reader->ReadIntptrValue());
+    cls.set_num_native_fields(reader->ReadIntptrValue());
     cls.set_class_state(reader->Read<int8_t>());
     if (reader->Read<bool>()) {
       cls.set_is_const();
     }
     if (reader->Read<bool>()) {
       cls.set_is_interface();
     }
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
@@ skipping 18 matching lines @@
   writer->WriteSerializationMarker(kInlined, object_id);
 
   if ((kind == Snapshot::kFull) ||
       (kind == Snapshot::kScript && !IsCreatedFromSnapshot())) {
     // Write out the class and tags information.
     writer->WriteObjectHeader(Object::kClassClass, ptr()->tags_);
 
     // Write out all the non object pointer fields.
     // NOTE: cpp_vtable_ is not written.
     writer->Write<ObjectKind>(ptr()->instance_kind_);
-    writer->Write<intptr_t>(ptr()->instance_size_);
-    writer->Write<intptr_t>(ptr()->type_arguments_instance_field_offset_);
-    writer->Write<intptr_t>(ptr()->next_field_offset_);
-    writer->Write<intptr_t>(ptr()->num_native_fields_);
+    writer->WriteIntptrValue(ptr()->instance_size_);
+    writer->WriteIntptrValue(ptr()->type_arguments_instance_field_offset_);
+    writer->WriteIntptrValue(ptr()->next_field_offset_);
+    writer->WriteIntptrValue(ptr()->num_native_fields_);
     writer->Write<int8_t>(ptr()->class_state_);
     writer->Write<bool>(ptr()->is_const_);
     writer->Write<bool>(ptr()->is_interface_);
 
     // Write out all the object pointer fields.
     SnapshotWriterVisitor visitor(writer);
     visitor.VisitPointers(from(), to());
   } else {
     writer->WriteClassId(this);
   }
 }
 
 
 RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate parameterized type object.
   UnresolvedClass& unresolved_class =
       UnresolvedClass::ZoneHandle(UnresolvedClass::New());
   reader->AddBackwardReference(object_id, &unresolved_class);
 
   // Set the object tags.
   unresolved_class.set_tags(tags);
 
   // Set all non object fields.
-  unresolved_class.set_token_index(reader->Read<intptr_t>());
+  unresolved_class.set_token_index(reader->ReadIntptrValue());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (unresolved_class.raw()->to() -
                        unresolved_class.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(unresolved_class.raw()->from() + i) = reader->ReadObject();
   }
   return unresolved_class.raw();
 }
 
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kUnresolvedClassClass, ptr()->tags_);
 
   // Write out all the non object pointer fields.
-  writer->Write<intptr_t>(ptr()->token_index_);
+  writer->WriteIntptrValue(ptr()->token_index_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawAbstractType* AbstractType::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
@@ skipping 71 matching lines @@
 
   // Allocate type parameter object.
   TypeParameter& type_parameter =
       TypeParameter::ZoneHandle(TypeParameter::New());
   reader->AddBackwardReference(object_id, &type_parameter);
 
   // Set the object tags.
   type_parameter.set_tags(tags);
 
   // Set all non object fields.
-  type_parameter.set_index(reader->Read<intptr_t>());
+  type_parameter.set_index(reader->ReadIntptrValue());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (type_parameter.raw()->to() -
                        type_parameter.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(type_parameter.raw()->from() + i) = reader->ReadObject();
   }
 
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTypeParameterClass, ptr()->tags_);
 
   // Write out all the non object pointer fields.
-  writer->Write<intptr_t>(ptr()->index_);
+  writer->WriteIntptrValue(ptr()->index_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawInstantiatedType* InstantiatedType::ReadFrom(SnapshotReader* reader,
                                                 intptr_t object_id,
@@ skipping 57 matching lines @@
 }
 
 
 RawTypeArguments* TypeArguments::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->Read<intptr_t>());
+  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
   intptr_t len = Smi::Value(smi_len);
 
   TypeArguments& type_arguments =
       TypeArguments::Handle(TypeArguments::New(len));
   reader->AddBackwardReference(object_id, &type_arguments);
 
   // Now set all the object fields.
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type ^= reader->ReadObject();
@@ skipping 90 matching lines @@
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate function object.
   Function& func = Function::ZoneHandle(Function::New());
   reader->AddBackwardReference(object_id, &func);
 
   // Set the object tags.
   func.set_tags(tags);
 
   // Set all the non object fields.
-  func.set_token_index(reader->Read<intptr_t>());
-  func.set_num_fixed_parameters(reader->Read<intptr_t>());
-  func.set_num_optional_parameters(reader->Read<intptr_t>());
-  func.set_invocation_counter(reader->Read<intptr_t>());
-  func.set_deoptimization_counter(reader->Read<intptr_t>());
-  func.set_kind(static_cast<RawFunction::Kind >(reader->Read<intptr_t>()));
+  func.set_token_index(reader->ReadIntptrValue());
+  func.set_num_fixed_parameters(reader->ReadIntptrValue());
+  func.set_num_optional_parameters(reader->ReadIntptrValue());
+  func.set_invocation_counter(reader->ReadIntptrValue());
+  func.set_deoptimization_counter(reader->ReadIntptrValue());
+  func.set_kind(static_cast<RawFunction::Kind >(reader->ReadIntptrValue()));
   func.set_is_static(reader->Read<bool>());
   func.set_is_const(reader->Read<bool>());
   func.set_is_optimizable(reader->Read<bool>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (func.raw()->to() - func.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(func.raw()->from() + i) = reader->ReadObject();
   }
 
   return func.raw();
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kFunctionClass, ptr()->tags_);
 
   // Write out all the non object fields.
-  writer->Write<intptr_t>(ptr()->token_index_);
-  writer->Write<intptr_t>(ptr()->num_fixed_parameters_);
-  writer->Write<intptr_t>(ptr()->num_optional_parameters_);
-  writer->Write<intptr_t>(ptr()->invocation_counter_);
-  writer->Write<intptr_t>(ptr()->deoptimization_counter_);
-  writer->Write<intptr_t>(ptr()->kind_);
+  writer->WriteIntptrValue(ptr()->token_index_);
+  writer->WriteIntptrValue(ptr()->num_fixed_parameters_);
+  writer->WriteIntptrValue(ptr()->num_optional_parameters_);
+  writer->WriteIntptrValue(ptr()->invocation_counter_);
+  writer->WriteIntptrValue(ptr()->deoptimization_counter_);
+  writer->WriteIntptrValue(ptr()->kind_);
   writer->Write<bool>(ptr()->is_static_);
   writer->Write<bool>(ptr()->is_const_);
   writer->Write<bool>(ptr()->is_optimizable_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate field object.
   Field& field = Field::ZoneHandle(Field::New());
   reader->AddBackwardReference(object_id, &field);
 
   // Set the object tags.
   field.set_tags(tags);
 
   // Set all non object fields.
-  field.set_token_index(reader->Read<intptr_t>());
+  field.set_token_index(reader->ReadIntptrValue());
   field.set_is_static(reader->Read<bool>());
   field.set_is_final(reader->Read<bool>());
   field.set_has_initializer(reader->Read<bool>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (field.raw()->to() - field.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(field.raw()->from() + i) = reader->ReadObject();
   }
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kFieldClass, ptr()->tags_);
 
   // Write out all the non object fields.
-  writer->Write<intptr_t>(ptr()->token_index_);
+  writer->WriteIntptrValue(ptr()->token_index_);
   writer->Write<bool>(ptr()->is_static_);
   writer->Write<bool>(ptr()->is_final_);
   writer->Write<bool>(ptr()->has_initializer_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Read the length so that we can determine number of tokens to read.
-  RawSmi* smi_len = GetSmi(reader->Read<intptr_t>());
+  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
   intptr_t len = Smi::Value(smi_len);
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(TokenStream::New(len));
   reader->AddBackwardReference(object_id, &token_stream);
 
   // Set the object tags.
   token_stream.set_tags(tags);
 
   // Read the token stream into the TokenStream.
   String& literal = String::Handle();
   for (intptr_t i = 0; i < len; i++) {
     Token::Kind kind = static_cast<Token::Kind>(
-        Smi::Value(GetSmi(reader->Read<intptr_t>())));
+        Smi::Value(GetSmi(reader->ReadIntptrValue())));
     literal ^= reader->ReadObject();
     token_stream.SetTokenAt(i, kind, literal);
   }
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
@@ skipping 79 matching lines @@
     library_url ^= reader->ReadObject();
     library = Library::LookupLibrary(library_url);
   } else {
     // Allocate library object.
     library = Library::New();
 
     // Set the object tags.
     library.set_tags(tags);
 
     // Set all non object fields.
-    library.raw_ptr()->num_imports_ = reader->Read<intptr_t>();
-    library.raw_ptr()->num_imported_into_ = reader->Read<intptr_t>();
-    library.raw_ptr()->num_anonymous_ = reader->Read<intptr_t>();
+    library.raw_ptr()->num_imports_ = reader->ReadIntptrValue();
+    library.raw_ptr()->num_imported_into_ = reader->ReadIntptrValue();
+    library.raw_ptr()->num_anonymous_ = reader->ReadIntptrValue();
     library.raw_ptr()->corelib_imported_ = reader->Read<bool>();
     library.raw_ptr()->load_state_ = reader->Read<int8_t>();
     // The native resolver is not serialized.
     Dart_NativeEntryResolver resolver =
         reader->Read<Dart_NativeEntryResolver>();
     ASSERT(resolver == NULL);
     library.set_native_entry_resolver(resolver);
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
@@ skipping 18 matching lines @@
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kLibraryClass, ptr()->tags_);
 
   if (IsCreatedFromSnapshot()) {
     ASSERT(kind != Snapshot::kFull);
     // Write out library URL so that it can be looked up when reading.
     writer->WriteObject(ptr()->url_);
   } else {
     // Write out all non object fields.
-    writer->Write<intptr_t>(ptr()->num_imports_);
-    writer->Write<intptr_t>(ptr()->num_imported_into_);
-    writer->Write<intptr_t>(ptr()->num_anonymous_);
+    writer->WriteIntptrValue(ptr()->num_imports_);
+    writer->WriteIntptrValue(ptr()->num_imported_into_);
+    writer->WriteIntptrValue(ptr()->num_anonymous_);
     writer->Write<bool>(ptr()->corelib_imported_);
     writer->Write<int8_t>(ptr()->load_state_);
     // We do not serialize the native resolver over, this needs to be explicitly
     // set after deserialization.
     writer->Write<Dart_NativeEntryResolver>(NULL);
 
     // Write out all the object pointer fields.
     SnapshotWriterVisitor visitor(writer);
     visitor.VisitPointers(from(), to());
   }
@@ skipping 134 matching lines @@
 }
 
 
 RawContext* Context::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
-  intptr_t num_vars = reader->Read<intptr_t>();
+  intptr_t num_vars = reader->ReadIntptrValue();
   Context& context = Context::ZoneHandle(
       Context::New(num_vars,
                    (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
   reader->AddBackwardReference(object_id, &context);
 
   // Set the object tags.
   context.set_tags(tags);
 
   // Set the isolate implicitly.
   context.set_isolate(Isolate::Current());
@@ skipping 15 matching lines @@
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kContextClass, ptr()->tags_);
 
   // Write out num of variables in the context.
-  writer->Write<intptr_t>(ptr()->num_variables_);
+  writer->WriteIntptrValue(ptr()->num_variables_);
 
   // Can't serialize the isolate pointer, we set it implicitly on read.
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
 
 RawContextScope* ContextScope::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Allocate context scope object.
-  intptr_t num_vars = reader->Read<intptr_t>();
+  intptr_t num_vars = reader->ReadIntptrValue();
   ContextScope& scope = ContextScope::ZoneHandle(ContextScope::New(num_vars));
   reader->AddBackwardReference(object_id, &scope);
 
   // Set the object tags.
   scope.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (scope.raw()->to(num_vars) - scope.raw()->from());
@@ skipping 11 matching lines @@
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kContextScopeClass, ptr()->tags_);
 
   // Serialize number of variables.
-  writer->Write<intptr_t>(ptr()->num_variables_);
+  writer->WriteIntptrValue(ptr()->num_variables_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
 
 RawUnhandledException* UnhandledException::ReadFrom(SnapshotReader* reader,
                                                     intptr_t object_id,
                                                     intptr_t tags,
@@ skipping 84 matching lines @@
 }
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read in the HexCString representation of the bigint.
-  intptr_t len = reader->Read<intptr_t>();
+  intptr_t len = reader->ReadIntptrValue();
   char* str = reinterpret_cast<char*>(ZoneAllocator(len + 1));
   str[len] = '\0';
   for (intptr_t i = 0; i < len; i++) {
     str[i] = reader->Read<uint8_t>();
   }
 
   // Create a Bigint object from HexCString.
   Bigint& obj = Bigint::ZoneHandle(BigintOperations::FromHexCString(str));
 
   // If it is a canonical constant make it one.
@@ skipping 17 matching lines @@
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(ObjectStore::kBigintClass, ptr()->tags_);
 
   // Write out the bigint value as a HEXCstring.
   ptr()->bn_.d = ptr()->data_;
   const char* str = BigintOperations::ToHexCString(&ptr()->bn_, &ZoneAllocator);
   intptr_t len = strlen(str);
-  writer->Write<intptr_t>(len-2);
+  writer->WriteIntptrValue(len-2);
   for (intptr_t i = 2; i < len; i++) {
     writer->Write<uint8_t>(str[i]);
   }
 }
 
 
 RawDouble* Double::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
@@ skipping 50 matching lines @@
 }
 
 
 template<typename HandleType, typename CharacterType>
 RawString* String::ReadFromImpl(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->Read<intptr_t>());
+  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
   intptr_t len = Smi::Value(smi_len);
-  RawSmi* smi_hash = GetSmi(reader->Read<intptr_t>());
+  RawSmi* smi_hash = GetSmi(reader->ReadIntptrValue());
 
   HandleType& str_obj = HandleType::ZoneHandle();
   if (kind != Snapshot::kFull && RawObject::IsCanonical(tags)) {
     CharacterType* ptr = reinterpret_cast<CharacterType*>(ZoneAllocator(len));
     for (intptr_t i = 0; i < len; i++) {
       ptr[i] = reader->Read<CharacterType>();
     }
     str_obj ^= String::NewSymbol(ptr, len);
   } else {
     // Set up the string object.
@@ skipping 203 matching lines @@
 
 
 template <class T>
 static RawObject* ArrayReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->Read<intptr_t>());
+  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
   intptr_t len = Smi::Value(smi_len);
   T& result = T::Handle(
       T::New(len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
   reader->AddBackwardReference(object_id, &result);
 
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the object fields.
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
@@ skipping 134 matching lines @@
 
 
 RawJSRegExp* JSRegExp::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->Read<intptr_t>());
+  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
   intptr_t len = Smi::Value(smi_len);
 
   // Allocate JSRegExp object.
   JSRegExp& regex = JSRegExp::ZoneHandle(
       JSRegExp::New(len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
   reader->AddBackwardReference(object_id, &regex);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
-  regex.raw_ptr()->num_bracket_expressions_ = GetSmi(reader->Read<intptr_t>());
+  regex.raw_ptr()->num_bracket_expressions_ = GetSmi(reader->ReadIntptrValue());
   String& pattern = String::Handle();
   pattern ^= reader->ReadObject();
   regex.raw_ptr()->pattern_ = pattern.raw();
-  regex.raw_ptr()->type_ = reader->Read<intptr_t>();
-  regex.raw_ptr()->flags_ = reader->Read<intptr_t>();
+  regex.raw_ptr()->type_ = reader->ReadIntptrValue();
+  regex.raw_ptr()->flags_ = reader->ReadIntptrValue();
 
   // TODO(5411462): Need to implement a way of recompiling the regex.
 
   return regex.raw();
 }
 
 
 void RawJSRegExp::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(ObjectStore::kJSRegExpClass, ptr()->tags_);
 
   // Write out the data length field.
   writer->Write<RawObject*>(ptr()->data_length_);
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObject(ptr()->pattern_);
-  writer->Write<intptr_t>(ptr()->type_);
-  writer->Write<intptr_t>(ptr()->flags_);
+  writer->WriteIntptrValue(ptr()->type_);
+  writer->WriteIntptrValue(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 }  // namespace dart