VM-internalize the default Map implementation.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 2279 matching lines @@
 FOR_EACH_FUNCTION_KIND_BIT(DEFINE_ACCESSORS)
 #undef DEFINE_ACCESSORS
 
  private:
   void set_ic_data_array(const Array& value) const;
 
   enum KindTagBits {
     kKindTagPos = 0,
     kKindTagSize = 4,
     kRecognizedTagPos = kKindTagPos + kKindTagSize,
-    kRecognizedTagSize = 8,
+    kRecognizedTagSize = 9,
     kModifierPos = kRecognizedTagPos + kRecognizedTagSize,
     kModifierSize = 2,
     kLastModifierBitPos = kModifierPos + (kModifierSize - 1),
     // Single bit sized fields start here.
 #define DECLARE_BIT(name, _) k##name##Bit,
 FOR_EACH_FUNCTION_KIND_BIT(DECLARE_BIT)
 #undef DECLARE_BIT
     kNumTagBits
   };
 
@@ skipping 4362 matching lines @@
   }
 
   static const int kDefaultInitialCapacity = 4;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Array;
   friend class Class;
 };
 
 
-// Corresponds to
-// - "new Map()",
-// - non-const map literals, and
-// - the default constructor of LinkedHashMap in dart:collection.
-class LinkedHashMap : public Instance {
- public:
-  intptr_t Length() const;
-  RawObject* LookUp(const Object& key) const;
-  void InsertOrUpdate(const Object& key, const Object& value) const;
-  bool Contains(const Object& key) const;
-  RawObject* Remove(const Object& key) const;
-  void Clear() const;
-  // List of key, value pairs in iteration (i.e., key insertion) order.
-  RawArray* ToArray() const;
-
-  static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawLinkedHashMap));
-  }
-
-  static RawLinkedHashMap* New(Heap::Space space = Heap::kNew);
-
-  virtual RawTypeArguments* GetTypeArguments() const {
-    return raw_ptr()->type_arguments_;
-  }
-  virtual void SetTypeArguments(const TypeArguments& value) const {
-    ASSERT(value.IsNull() || ((value.Length() >= 2) && value.IsInstantiated()));
-    StorePointer(&raw_ptr()->type_arguments_, value.raw());
-  }
-  static intptr_t type_arguments_offset() {
-    return OFFSET_OF(RawLinkedHashMap, type_arguments_);
-  }
-
-  // Called whenever the set of keys changes.
-  void SetModified() const;
-  RawInstance* GetModificationMark(bool create) const;
-
- private:
-  RawArray* data() const { return raw_ptr()->data_; }
-  void SetData(const Array& value) const {
-    StorePointer(&raw_ptr()->data_, value.raw());
-  }
-
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap, Instance);
-  friend class Class;
-};
-
-
 class Float32x4 : public Instance {
  public:
   static RawFloat32x4* New(float value0, float value1, float value2,
                            float value3, Heap::Space space = Heap::kNew);
   static RawFloat32x4* New(simd128_value_t value,
                            Heap::Space space = Heap::kNew);
 
   float x() const;
   float y() const;
   float z() const;
@@ skipping 450 matching lines @@
     return kWordSize * kDataOffset;
   }
 
  private:
   enum {
     kDataOffset = 1,
   };
 };
 
 
+// Corresponds to
+// - "new Map()",
+// - non-const map literals, and
+// - the default constructor of LinkedHashMap in dart:collection.
+class LinkedHashMap : public Instance {
+ public:
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawLinkedHashMap));
+  }
+
+  // Allocates a map with some default capacity, just like "new Map()".
+  static RawLinkedHashMap* NewDefault(Heap::Space space = Heap::kNew);
+  static RawLinkedHashMap* New(const Array& data,
+                               const TypedData& index,
+                               intptr_t hash_mask,
+                               intptr_t used_data,
+                               intptr_t deleted_keys,
+                               Heap::Space space = Heap::kNew);
+
+  virtual RawTypeArguments* GetTypeArguments() const {
+    return raw_ptr()->type_arguments_;
+  }
+  virtual void SetTypeArguments(const TypeArguments& value) const {
+    ASSERT(value.IsNull() || ((value.Length() >= 2) && value.IsInstantiated()));
+    StorePointer(&raw_ptr()->type_arguments_, value.raw());
+  }
+  static intptr_t type_arguments_offset() {
+    return OFFSET_OF(RawLinkedHashMap, type_arguments_);
+  }
+
+  RawTypedData* index() const {
+    return raw_ptr()->index_;
+  }
+  void SetIndex(const TypedData& value) const {
+    StorePointer(&raw_ptr()->index_, value.raw());
+  }
+  static intptr_t index_offset() {
+    return OFFSET_OF(RawLinkedHashMap, index_);
+  }
+
+  RawArray* data() const {
+    return raw_ptr()->data_;
+  }
+  void SetData(const Array& value) const {
+    StorePointer(&raw_ptr()->data_, value.raw());
+  }
+  static intptr_t data_offset() {
+    return OFFSET_OF(RawLinkedHashMap, data_);
+  }
+
+  RawSmi* hash_mask() const {
+    return raw_ptr()->hash_mask_;
+  }
+  void SetHashMask(intptr_t value) const {
+    StoreSmi(&raw_ptr()->hash_mask_, Smi::New(value));
+  }
+  static intptr_t hash_mask_offset() {
+    return OFFSET_OF(RawLinkedHashMap, hash_mask_);
+  }
+
+  RawSmi* used_data() const {
+    return raw_ptr()->used_data_;
+  }
+  void SetUsedData(intptr_t value) const {
+    StoreSmi(&raw_ptr()->used_data_, Smi::New(value));
+  }
+  static intptr_t used_data_offset() {
+    return OFFSET_OF(RawLinkedHashMap, used_data_);
+  }
+
+  RawSmi* deleted_keys() const {
+    return raw_ptr()->deleted_keys_;
+  }
+  void SetDeletedKeys(intptr_t value) const {
+    StoreSmi(&raw_ptr()->deleted_keys_, Smi::New(value));
+  }
+  static intptr_t deleted_keys_offset() {
+    return OFFSET_OF(RawLinkedHashMap, deleted_keys_);
+  }
+
+ private:
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap, Instance);
+
+  // Allocate a map, but leave all fields set to null.
+  // Used during deserialization (since map might contain itself as key/value).
+  static RawLinkedHashMap* NewUninitialized(Heap::Space space = Heap::kNew);
+
+  friend class Class;
+};
+
+
 class Closure : public AllStatic {
  public:
   static RawFunction* function(const Instance& closure) {
     return *FunctionAddr(closure);
   }
   static intptr_t function_offset() {
     return static_cast<intptr_t>(kFunctionOffset * kWordSize);
   }
 
   static RawContext* context(const Instance& closure) {
@@ skipping 535 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_