VM-internalize the default Map implementation.

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 2200 matching lines @@
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   LinkedHashMap& map = LinkedHashMap::ZoneHandle(
       reader->zone(), LinkedHashMap::null());
   if (kind == Snapshot::kFull || kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   } else {
-    map = LinkedHashMap::New(HEAP_SPACE(kind));
+    // Since the map might contain itself as a key or value, allocate first.
+    map = LinkedHashMap::NewUninitialized(HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &map, kIsDeserialized);
+  *(reader->TypeArgumentsHandle()) ^= reader->ReadObjectImpl();
+  map.SetTypeArguments(*(reader->TypeArgumentsHandle()));
+  // Note: If the map is too big for a 32-bit VM, then Array::New will FATAL.
   *(reader->ArrayHandle()) ^= reader->ReadObjectImpl();
   map.SetData(*(reader->ArrayHandle()));
-  *(reader->TypeArgumentsHandle()) = reader->ArrayHandle()->GetTypeArguments();
-  map.SetTypeArguments(*(reader->TypeArgumentsHandle()));
+  *(reader->TypedDataHandle()) ^= reader->ReadObjectImpl();
+  map.SetIndex(*(reader->TypedDataHandle()));
+  map.SetHashMask(reader->ReadSmiValue());
+  map.SetUsedData(reader->ReadSmiValue());
+  map.SetDeletedKeys(reader->ReadSmiValue());
+  /*
+  *(reader->SmiHandle()) ^= reader->ReadObjectImpl();
+  map.SetHashMask(reader->SmiHandle()->Value());
+  *(reader->SmiHandle()) ^= reader->ReadObjectImpl();
+  map.SetUsedData(reader->SmiHandle()->Value());
+  *(reader->SmiHandle()) ^= reader->ReadObjectImpl();
+  map.SetDeletedKeys(reader->SmiHandle()->Value());
+  */

[siva, 2015/05/22 16:27:11]

Why is this done this way and not using the from/to loop like other types?

[koda, 2015/05/26 12:22:05]

Done.

   return map.raw();
 }
 
 
 void RawLinkedHashMap::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   if (kind == Snapshot::kFull || kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   }
   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(kLinkedHashMapCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
-  // Write out the backing array.
-  // TODO(koda): Serialize as pairs (like ToArray) instead, to reduce space and
-  // support per-isolate salted hash codes.
+  // Write out the fields.
+  // TODO(koda): Serialize only used parts of data_ (after compaction), to
+  // reduce space and support per-isolate salted hash codes. All allowed keys
+  // have types for which we can rehash without running Dart code.
+  writer->WriteObjectImpl(ptr()->type_arguments_);
   writer->WriteObjectImpl(ptr()->data_);
+  writer->WriteObjectImpl(ptr()->index_);
+  writer->Write<RawObject*>(ptr()->hash_mask_);
+  writer->Write<RawObject*>(ptr()->used_data_);
+  writer->Write<RawObject*>(ptr()->deleted_keys_);

[siva, 2015/05/22 16:27:11]

Ditto question.

[koda, 2015/05/26 12:22:05]

Done.

 }
 
 
 RawFloat32x4* Float32x4::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the values.
   float value0 = reader->Read<float>();
@@ skipping 615 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