Add additional asserts in the snapshot writer/reader code.

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 230 matching lines @@
 
   // Write out all the object pointer fields.
   visitor.VisitPointers(from(), to());
 }
 
 
 RawInstantiatedType* InstantiatedType::ReadFrom(SnapshotReader* reader,
                                                 intptr_t object_id,
                                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind == Snapshot::kMessage);
 
   // Allocate instantiated type object.
   InstantiatedType& instantiated_type =
       InstantiatedType::ZoneHandle(InstantiatedType::New());
   reader->AddBackwardReference(object_id, &instantiated_type);
 
   // Now set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (instantiated_type.raw()->to() -
                        instantiated_type.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(instantiated_type.raw()->from() + i) = reader->ReadObject();
   }
   return instantiated_type.raw();
 }
 
 
 void RawInstantiatedType::WriteTo(SnapshotWriter* writer,
                                   intptr_t object_id,
                                   Snapshot::Kind kind) {
   ASSERT(writer != NULL);
+  ASSERT(kind == Snapshot::kMessage);
   SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteObjectHeader(kInlined, object_id);
 
   // Write out the class information.
   writer->WriteObjectHeader(kObjectId, Object::kInstantiatedTypeClass);
 
   // Write out all the object pointer fields.
   visitor.VisitPointers(from(), to());
@@ skipping 61 matching lines @@
     writer->WriteObject(ptr()->types_[i]);
   }
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind == Snapshot::kMessage);
 
   // Allocate instantiated types object.
   InstantiatedTypeArguments& instantiated_type_arguments =
       InstantiatedTypeArguments::ZoneHandle(InstantiatedTypeArguments::New());
   reader->AddBackwardReference(object_id, &instantiated_type_arguments);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (instantiated_type_arguments.raw()->to() -
                        instantiated_type_arguments.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(instantiated_type_arguments.raw()->from() + i) = reader->ReadObject();
   }
   return instantiated_type_arguments.raw();
 }
 
 
 void RawInstantiatedTypeArguments::WriteTo(SnapshotWriter* writer,
                                            intptr_t object_id,
                                            Snapshot::Kind kind) {
   ASSERT(writer != NULL);
+  ASSERT(kind == Snapshot::kMessage);
   SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteObjectHeader(kInlined, object_id);
 
   // Write out the class information.
   writer->WriteObjectHeader(kObjectId, Object::kInstantiatedTypeArgumentsClass);
 
   // Write out all the object pointer fields.
   visitor.VisitPointers(from(), to());
@@ skipping 405 matching lines @@
 
   // Write out all the object pointer fields.
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
 
 RawContextScope* ContextScope::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
+  ASSERT(kind == Snapshot::kMessage);
 
   // Allocate context scope object.
   intptr_t num_vars = reader->Read<intptr_t>();
   ContextScope& scope = ContextScope::ZoneHandle(ContextScope::New(num_vars));
   reader->AddBackwardReference(object_id, &scope);
 
   // 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());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(scope.raw()->from() + i) = reader->ReadObject();
   }
 
   return scope.raw();
 }
 
 
 void RawContextScope::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer != NULL);
+  ASSERT(kind == Snapshot::kMessage);
   SnapshotWriterVisitor visitor(writer);
 
   // Write out the serialization header value for this object.
   writer->WriteObjectHeader(kInlined, object_id);
 
   // Write out the class information.
   writer->WriteObjectHeader(kObjectId, Object::kContextScopeClass);
 
   // Serialize number of variables.
   writer->Write<intptr_t>(ptr()->num_variables_);
@@ skipping 504 matching lines @@
                             intptr_t object_id,
                             Snapshot::Kind kind) {
   UNIMPLEMENTED();
 }
 
 
 RawJSRegExp* JSRegExp::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 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>());
   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);
 
   // Read and Set all the other fields.
   regex.raw_ptr()->num_bracket_expressions_ = GetSmi(reader->Read<intptr_t>());
   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>();
 
   // 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->WriteObjectHeader(kInlined, object_id);
 
   // Write out the class information.
   writer->WriteObjectHeader(kObjectId, ObjectStore::kJSRegExpClass);
 
   // 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_);
 
   // Do not write out the data part which is native.
 }
 
 }  // namespace dart