Request for comments on overall approach.

runtime/vm/raw_object_snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
@@ skipping 65 matching lines @@
 
 void RawClass::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);
 
   if ((kind == Snapshot::kFull) ||
-      (kind == Snapshot::kScript && !IsCreatedFromSnapshot())) {
+      (kind == Snapshot::kScript &&
+       !CreatedFromSnapshotTag::decode(writer->GetObjectTags(this)))) {
     // Write out the class and tags information.
-    writer->WriteObjectHeader(Object::kClassClass, ptr()->tags_);
+    writer->WriteObjectHeader(Object::kClassClass, writer->GetObjectTags(this));
 
     // Write out all the non object pointer fields.
     // NOTE: cpp_vtable_ is not written.
     writer->Write<ObjectKind>(ptr()->instance_kind_);
     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->WriteIntptrValue(ptr()->token_index_);
     writer->Write<int8_t>(ptr()->class_state_);
@@ skipping 40 matching lines @@
 
 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_);
+  writer->WriteObjectHeader(Object::kUnresolvedClassClass,
+                            writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_index_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
@@ skipping 50 matching lines @@
 
 void RawType::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::kTypeClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kTypeClass, writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_index_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
@@ skipping 32 matching lines @@
 
 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_);
+  writer->WriteObjectHeader(Object::kTypeParameterClass,
+                            writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->index_);
   writer->WriteIntptrValue(ptr()->token_index_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
@@ skipping 50 matching lines @@
 
 void RawTypeArguments::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::kTypeArgumentsClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kTypeArgumentsClass,
+                            writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the individual types.
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < len; i++) {
     writer->WriteObject(ptr()->types_[i]);
   }
 }
@@ skipping 32 matching lines @@
                                            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(Object::kInstantiatedTypeArgumentsClass,
-                            ptr()->tags_);
+                            writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawFunction* Function::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
@@ skipping 30 matching lines @@
   }
 
   return func.raw();
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
+  ASSERT(kind != Snapshot::kMessage &&
+         !CreatedFromSnapshotTag::decode(writer->GetObjectTags(this)));
 
   // 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_);
+  writer->WriteObjectHeader(Object::kFunctionClass,
+                            writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->WriteIntptrValue(ptr()->token_index_);
   writer->WriteIntptrValue(ptr()->end_token_index_);
   writer->WriteIntptrValue(ptr()->num_fixed_parameters_);
   writer->WriteIntptrValue(ptr()->num_optional_parameters_);
   writer->WriteIntptrValue(ptr()->usage_counter_);
   writer->WriteIntptrValue(ptr()->deoptimization_counter_);
   writer->WriteIntptrValue(ptr()->kind_);
   writer->Write<bool>(ptr()->is_static_);
@@ skipping 35 matching lines @@
   }
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
+  ASSERT(kind != Snapshot::kMessage &&
+         !CreatedFromSnapshotTag::decode(writer->GetObjectTags(this)));
 
   // 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_);
+  writer->WriteObjectHeader(Object::kFieldClass, writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   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());
@@ skipping 30 matching lines @@
 void RawLiteralToken::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(Object::kLiteralTokenClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kLiteralTokenClass,
+                            writer->GetObjectTags(this));
 
   // Write out the kind field.
   writer->Write<intptr_t>(ptr()->kind_);
 
   // Write out literal and value fields.
   writer->WriteObject(ptr()->literal_);
   writer->WriteObject(ptr()->value_);
 }
 
 
@@ skipping 21 matching lines @@
     token_stream.SetTokenAt(i, *reader->ObjectHandle());
   }
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
+  ASSERT(kind != Snapshot::kMessage &&
+         !CreatedFromSnapshotTag::decode(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
-  writer->WriteObjectHeader(Object::kTokenStreamClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kTokenStreamClass,
+                            writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the token stream (token kind and literal).
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < TokenStream::StreamLength(len); i++) {
     writer->WriteObject(ptr()->data_[i]);
   }
 }
@@ skipping 26 matching lines @@
 
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
-  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
+  ASSERT(kind != Snapshot::kMessage &&
+         !CreatedFromSnapshotTag::decode(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
-  writer->WriteObjectHeader(Object::kScriptClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kScriptClass, writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   writer->WriteObject(ptr()->url_);
   writer->WriteObject(ptr()->tokens_);
 }
 
 
 RawLibrary* Library::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
@@ skipping 48 matching lines @@
 void RawLibrary::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(Object::kLibraryClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kLibraryClass, writer->GetObjectTags(this));
 
-  if (IsCreatedFromSnapshot()) {
+  if (CreatedFromSnapshotTag::decode(writer->GetObjectTags(this))) {
     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->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_);
@@ skipping 38 matching lines @@
   }
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
+  ASSERT(kind != Snapshot::kMessage &&
+         !CreatedFromSnapshotTag::decode(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
-  writer->WriteObjectHeader(Object::kLibraryPrefixClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kLibraryPrefixClass,
+                            writer->GetObjectTags(this));
 
   // Write out all non object fields.
   writer->WriteIntptrValue(ptr()->num_libs_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
@@ skipping 131 matching lines @@
 
 void RawContext::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::kContextClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kContextClass, writer->GetObjectTags(this));
 
   // Write out num of variables in the context.
   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_));
 }
@@ skipping 30 matching lines @@
 void RawContextScope::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(Object::kContextScopeClass, ptr()->tags_);
+  writer->WriteObjectHeader(Object::kContextScopeClass,
+                            writer->GetObjectTags(this));
 
   // Serialize number of variables.
   writer->WriteIntptrValue(ptr()->num_variables_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
 
@@ skipping 156 matching lines @@
 
 void RawMint::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(ObjectStore::kMintClass, ptr()->tags_);
+  writer->WriteObjectHeader(ObjectStore::kMintClass,
+                            writer->GetObjectTags(this));
 
   // Write out the 64 bit value.
   writer->Write<int64_t>(ptr()->value_);
 }
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
@@ skipping 28 matching lines @@
 
 void RawBigint::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(ObjectStore::kBigintClass, ptr()->tags_);
+  writer->WriteObjectHeader(ObjectStore::kBigintClass,
+                            writer->GetObjectTags(this));
 
   // Write out the bigint value as a HEXCstring.
   intptr_t length = ptr()->signed_length_;
   bool is_negative = false;
   if (length <= 0) {
     length = -length;
     is_negative = true;
   }
   uword data_start = reinterpret_cast<uword>(ptr()) + sizeof(RawBigint);
   const char* str = BigintOperations::ToHexCString(
@@ skipping 50 matching lines @@
 
 void RawDouble::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(ObjectStore::kDoubleClass, ptr()->tags_);
+  writer->WriteObjectHeader(ObjectStore::kDoubleClass,
+                            writer->GetObjectTags(this));
 
   // Write out the double value.
   writer->Write<double>(ptr()->value_);
 }
 
 
 RawString* String::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
@@ skipping 160 matching lines @@
 }
 
 
 void RawOneByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   StringWriteTo(writer,
                 object_id,
                 kind,
                 ObjectStore::kOneByteStringClass,
-                ptr()->tags_,
+                writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->data_);
 }
 
 
 void RawTwoByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   StringWriteTo(writer,
                 object_id,
                 kind,
                 ObjectStore::kTwoByteStringClass,
-                ptr()->tags_,
+                writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->data_);
 }
 
 
 void RawFourByteString::WriteTo(SnapshotWriter* writer,
                                 intptr_t object_id,
                                 Snapshot::Kind kind) {
   StringWriteTo(writer,
                 object_id,
                 kind,
                 ObjectStore::kFourByteStringClass,
-                ptr()->tags_,
+                writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->data_);
 }
 
 
 RawExternalOneByteString* ExternalOneByteString::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
@@ skipping 24 matching lines @@
 
 
 void RawExternalOneByteString::WriteTo(SnapshotWriter* writer,
                                        intptr_t object_id,
                                        Snapshot::Kind kind) {
   // Serialize as a non-external one byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
                 ObjectStore::kOneByteStringClass,
-                ptr()->tags_,
+                writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 void RawExternalTwoByteString::WriteTo(SnapshotWriter* writer,
                                        intptr_t object_id,
                                        Snapshot::Kind kind) {
   // Serialize as a non-external two byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
                 ObjectStore::kTwoByteStringClass,
-                ptr()->tags_,
+                writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 void RawExternalFourByteString::WriteTo(SnapshotWriter* writer,
                                         intptr_t object_id,
                                         Snapshot::Kind kind) {
   // Serialize as a non-external four byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
                 ObjectStore::kFourByteStringClass,
-                ptr()->tags_,
+                writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 RawBool* Bool::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
@@ skipping 91 matching lines @@
 }
 
 
 void RawArray::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ArrayWriteTo(writer,
                object_id,
                kind,
                ObjectStore::kArrayClass,
-               ptr()->tags_,
+               writer->GetObjectTags(this),
                ptr()->length_,
                ptr()->type_arguments_,
                ptr()->data());
 }
 
 
 void RawImmutableArray::WriteTo(SnapshotWriter* writer,
                                 intptr_t object_id,
                                 Snapshot::Kind kind) {
   ArrayWriteTo(writer,
                object_id,
                kind,
                ObjectStore::kImmutableArrayClass,
-               ptr()->tags_,
+               writer->GetObjectTags(this),
                ptr()->length_,
                ptr()->type_arguments_,
                ptr()->data());
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::ReadFrom(SnapshotReader* reader,
                                                       intptr_t object_id,
                                                       intptr_t tags,
                                                       Snapshot::Kind kind) {
@@ skipping 23 matching lines @@
 void RawGrowableObjectArray::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(ObjectStore::kGrowableObjectArrayClass,
-                            ptr()->tags_);
+                            writer->GetObjectTags(this));
 
   // Write out the used length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the Array object.
   writer->WriteObject(ptr()->data_);
 }
 
 
 RawByteArray* ByteArray::ReadFrom(SnapshotReader* reader,
@@ skipping 262 matching lines @@
 }
 
 
 void RawInt8Array::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt8ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawUint8Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint8ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawInt16Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt16ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawUint16Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint16ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawInt32Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt32ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawUint32Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint32ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawInt64Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt64ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawUint64Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint64ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawFloat32Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kFloat32ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawFloat64Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kFloat64ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->data_));
 }
 
 
 void RawExternalInt8Array::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt8ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalUint8Array::WriteTo(SnapshotWriter* writer,
                                     intptr_t object_id,
                                     Snapshot::Kind kind) {
   // Serialize as a non-external int8 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint8ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalInt16Array::WriteTo(SnapshotWriter* writer,
                                     intptr_t object_id,
                                     Snapshot::Kind kind) {
   // Serialize as a non-external int16 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt16ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalUint16Array::WriteTo(SnapshotWriter* writer,
                                      intptr_t object_id,
                                      Snapshot::Kind kind) {
   // Serialize as a non-external uint16 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint16ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalInt32Array::WriteTo(SnapshotWriter* writer,
                                     intptr_t object_id,
                                     Snapshot::Kind kind) {
   // Serialize as a non-external int32 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt32ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalUint32Array::WriteTo(SnapshotWriter* writer,
                                      intptr_t object_id,
                                      Snapshot::Kind kind) {
   // Serialize as a non-external uint32 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint32ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalInt64Array::WriteTo(SnapshotWriter* writer,
                                     intptr_t object_id,
                                     Snapshot::Kind kind) {
   // Serialize as a non-external int64 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kInt64ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalUint64Array::WriteTo(SnapshotWriter* writer,
                                      intptr_t object_id,
                                      Snapshot::Kind kind) {
   // Serialize as a non-external uint64 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kUint64ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalFloat32Array::WriteTo(SnapshotWriter* writer,
                                       intptr_t object_id,
                                       Snapshot::Kind kind) {
   // Serialize as a non-external float32 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kFloat32ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 void RawExternalFloat64Array::WriteTo(SnapshotWriter* writer,
                                       intptr_t object_id,
                                       Snapshot::Kind kind) {
   // Serialize as a non-external float64 array.
   ByteArrayWriteTo(writer,
                    object_id,
                    kind,
                    ObjectStore::kFloat64ArrayClass,
-                   ptr()->tags_,
+                   writer->GetObjectTags(this),
                    ptr()->length_,
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data()));
 }
 
 
 RawClosure* Closure::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   UNIMPLEMENTED();
@@ skipping 59 matching lines @@
 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_);
+  writer->WriteObjectHeader(ObjectStore::kJSRegExpClass,
+                            writer->GetObjectTags(this));
 
   // 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->WriteIntptrValue(ptr()->type_);
   writer->WriteIntptrValue(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 
 }  // namespace dart