Make deserialization more regular as prep for deferring canonicalization for types/instances.

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/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 50 matching lines @@
     cls.set_num_own_type_arguments(reader->Read<int16_t>());
     cls.set_num_native_fields(reader->Read<uint16_t>());
     cls.set_token_pos(reader->Read<int32_t>());
     cls.set_state_bits(reader->Read<uint16_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 = (cls.raw()->to() - cls.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      *(cls.raw()->from() + i) = reader->ReadObjectRef();
+      (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+       cls.StorePointer((cls.raw()->from() + i),
+                       reader->PassiveObjectHandle()->raw());
     }
   } else {
     cls ^= reader->ReadClassId(object_id);
   }
   return cls.raw();
 }
 
 
 void RawClass::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
@@ skipping 442 matching lines @@
   reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
   // Set the object tags.
   cls.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 = (cls.raw()->to() - cls.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(cls.raw()->from() + i) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    cls.StorePointer((cls.raw()->from() + i),
+                     reader->PassiveObjectHandle()->raw());
   }
 
   return cls.raw();
 }
 
 
 void RawPatchClass::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 88 matching lines @@
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set the object tags.
   data.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 = (data.raw()->to() - data.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(data.raw()->from() + i) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    data.StorePointer((data.raw()->from() + i),
+                      reader->PassiveObjectHandle()->raw());
   }
 
   return data.raw();
 }
 
 
 void RawRedirectionData::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 40 matching lines @@
   func.set_deoptimization_counter(reader->Read<int16_t>());
   func.set_kind_tag(reader->Read<uint32_t>());
   func.set_optimized_instruction_count(reader->Read<uint16_t>());
   func.set_optimized_call_site_count(reader->Read<uint16_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 = (func.raw()->to_snapshot() - func.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(func.raw()->from() + i) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    func.StorePointer((func.raw()->from() + i),
+                      reader->PassiveObjectHandle()->raw());
   }
 
   // Initialize all fields that are not part of the snapshot.
   func.ClearCode();
   func.set_ic_data_array(Object::null_array());
   return func.raw();
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
@@ skipping 48 matching lines @@
   field.set_token_pos(reader->Read<int32_t>());
   field.set_guarded_cid(reader->Read<int32_t>());
   field.set_is_nullable(reader->Read<int32_t>());
   field.set_kind_bits(reader->Read<uint8_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 = (field.raw()->to() - field.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(field.raw()->from() + i) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    field.StorePointer((field.raw()->from() + i),
+                       reader->PassiveObjectHandle()->raw());
   }
 
   field.InitializeGuardedListLengthInObjectOffset();
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
@@ skipping 33 matching lines @@
   LiteralToken& literal_token = LiteralToken::ZoneHandle(
       reader->isolate(), NEW_OBJECT(LiteralToken));
   reader->AddBackRef(object_id, &literal_token, kIsDeserialized);
 
   // Set the object tags.
   literal_token.set_tags(tags);
 
   // Read the token attributes.
   Token::Kind token_kind = static_cast<Token::Kind>(reader->Read<int32_t>());
   literal_token.set_kind(token_kind);
-  *reader->StringHandle() ^= reader->ReadObjectImpl();
-  literal_token.set_literal(*reader->StringHandle());
-  *reader->PassiveObjectHandle() = reader->ReadObjectImpl();
-  literal_token.set_value(*reader->PassiveObjectHandle());
+
+  // Set all the object fields.
+  // TODO(5411462): Need to assert No GC can happen here, even though
+  // allocations may happen.
+  intptr_t num_flds = (literal_token.raw()->to() - literal_token.raw()->from());
+  for (intptr_t i = 0; i <= num_flds; i++) {
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    literal_token.StorePointer((literal_token.raw()->from() + i),
+                               reader->PassiveObjectHandle()->raw());
+  }
 
   return literal_token.raw();
 }
 
 
 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->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kLiteralTokenCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the kind field.
   writer->Write<int32_t>(ptr()->kind_);
 
-  // Write out literal and value fields.
-  writer->WriteObjectImpl(ptr()->literal_);
-  writer->WriteObjectImpl(ptr()->value_);
+  // 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::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
@@ skipping 66 matching lines @@
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate script object.
   Script& script = Script::ZoneHandle(reader->isolate(), NEW_OBJECT(Script));
   reader->AddBackRef(object_id, &script, kIsDeserialized);
 
   // Set the object tags.
   script.set_tags(tags);
 
-  // Set all the object fields.
-  // TODO(5411462): Need to assert No GC can happen here, even though
-  // allocations may happen.
-  *reader->StringHandle() ^= reader->ReadObjectImpl();
-  script.set_url(*reader->StringHandle());
-  *reader->StringHandle() ^= String::null();
-  script.set_source(*reader->StringHandle());
-  TokenStream& stream = TokenStream::Handle();
-  stream ^= reader->ReadObjectImpl();
-  script.set_tokens(stream);
-
   script.StoreNonPointer(&script.raw_ptr()->line_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->col_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->kind_,
                          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 = (script.raw()->to_snapshot() - script.raw()->from());
+  for (intptr_t i = 0; i <= num_flds; i++) {
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    script.StorePointer((script.raw()->from() + i),
+                        reader->PassiveObjectHandle()->raw());
+  }
+  // Script wasn't allocated with nulls?
+  *reader->StringHandle() ^= String::null();
+  script.set_source(*reader->StringHandle());
+
   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::kScript) &&
           !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this))) ||
          (kind == Snapshot::kFull));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kScriptCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
-  // Write out all the object pointer fields.
-  writer->WriteObjectImpl(ptr()->url_);
-  writer->WriteObjectImpl(ptr()->tokens_);
-
+  // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->line_offset_);
   writer->Write<int32_t>(ptr()->col_offset_);
   writer->Write<int8_t>(ptr()->kind_);
+
+  // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
+  visitor.VisitPointers(from(), to_snapshot());
 }
 
 
 RawLibrary* Library::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
@@ skipping 38 matching lines @@
     ASSERT(symbol_resolver == NULL);
     library.set_native_entry_symbol_resolver(symbol_resolver);
     // The cache of loaded scripts is not serialized.
     library.StorePointer(&library.raw_ptr()->loaded_scripts_, Array::null());
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (library.raw()->to() - library.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      *(library.raw()->from() + i) = reader->ReadObjectRef();
+      (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+      library.StorePointer((library.raw()->from() + i),
+                           reader->PassiveObjectHandle()->raw());
     }
     if (kind != Snapshot::kFull) {
       library.Register();
     }
   }
   return library.raw();
 }
 
 
 void RawLibrary::WriteTo(SnapshotWriter* writer,
@@ skipping 62 matching lines @@
                          reader->Read<int32_t>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_deferred_load_,
                          reader->Read<bool>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_loaded_, 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 = (prefix.raw()->to() - prefix.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(prefix.raw()->from() + i) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    prefix.StorePointer((prefix.raw()->from() + i),
+                         reader->PassiveObjectHandle()->raw());
   }
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 34 matching lines @@
   reader->AddBackRef(object_id, &ns, kIsDeserialized);
 
   // Set the object tags.
   ns.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 = (ns.raw()->to() - ns.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(ns.raw()->from() + i) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    ns.StorePointer((ns.raw()->from() + i),
+                    reader->PassiveObjectHandle()->raw());
   }
 
   return ns.raw();
 }
 
 
 void RawNamespace::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 377 matching lines @@
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.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 = (result.raw()->to() - result.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(result.raw()->from() + i) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    result.StorePointer((result.raw()->from() + i),
+                         reader->PassiveObjectHandle()->raw());
   }
+
   return result.raw();
 }
 
 
 void RawUnhandledException::WriteTo(SnapshotWriter* writer,
                                     intptr_t object_id,
                                     Snapshot::Kind kind) {
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
@@ skipping 1065 matching lines @@
 
 
 RawStacktrace* Stacktrace::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind) {
   if (kind == Snapshot::kFull) {
     Stacktrace& result = Stacktrace::ZoneHandle(reader->isolate(),
                                                 reader->NewStacktrace());
     reader->AddBackRef(object_id, &result, kIsDeserialized);
 

[siva, 2014/10/13 23:28:17]

I think we should retain the comment that there are no non object fields.

[rmacnak, 2014/10/14 00:49:44]

There is a non-object field: the expand_inlined boolean below.

-    // There are no non object pointer fields.
-
-    // Read all the object pointer fields.
-    Array& array = Array::Handle(reader->isolate());
-    array ^= reader->ReadObjectRef();
-    result.set_code_array(array);
-    array ^= reader->ReadObjectRef();
-    result.set_pc_offset_array(array);
-
-    array ^= reader->ReadObjectRef();
-    result.set_catch_code_array(array);
-    array ^= reader->ReadObjectRef();
-    result.set_catch_pc_offset_array(array);
+    // Set all the object fields.
+    // TODO(5411462): Need to assert No GC can happen here, even though
+    // allocations may happen.
+    intptr_t num_flds = (result.raw()->to() - result.raw()->from());
+    for (intptr_t i = 0; i <= num_flds; i++) {
+      (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+      result.StorePointer((result.raw()->from() + i),
+                          reader->PassiveObjectHandle()->raw());
+    }
 
     bool expand_inlined = reader->Read<bool>();
     result.set_expand_inlined(expand_inlined);
 
     return result.raw();
   }
   UNREACHABLE();  // Stacktraces are not sent in a snapshot.
   return Stacktrace::null();
 }
 
@@ skipping 92 matching lines @@
 
   // Allocate the weak property object.
   WeakProperty& weak_property = WeakProperty::ZoneHandle(
       reader->isolate(), WeakProperty::New(HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &weak_property, kIsDeserialized);
 
   // Set the object tags.
   weak_property.set_tags(tags);
 
   // Set all the object fields.
-  weak_property.StorePointer(&weak_property.raw_ptr()->key_,
-                             reader->ReadObjectRef());
-  weak_property.StorePointer(&weak_property.raw_ptr()->value_,
-                             reader->ReadObjectRef());
+  // TODO(5411462): Need to assert No GC can happen here, even though
+  // allocations may happen.
+  intptr_t num_flds = (weak_property.raw()->to() -
+                       weak_property.raw()->from());
+  for (intptr_t i = 0; i <= num_flds; i++) {
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    weak_property.StorePointer((weak_property.raw()->from() + i),
+                               reader->PassiveObjectHandle()->raw());
+  }
 
   return weak_property.raw();
 }
 
 
 void RawWeakProperty::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
-  // Write out all the other fields.
-  writer->Write<RawObject*>(ptr()->key_);
-  writer->Write<RawObject*>(ptr()->value_);
+  // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
+  visitor.VisitPointers(from(), to());
 }
 
 
 RawMirrorReference* MirrorReference::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   UNREACHABLE();
   return MirrorReference::null();
 }
@@ skipping 29 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart