Add a weak property type to the virtual machine.

runtime/vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/token.h"
@@ skipping 71 matching lines @@
       V(ExternalUint16Array)                                                   \
       V(ExternalInt32Array)                                                    \
       V(ExternalUint32Array)                                                   \
       V(ExternalInt64Array)                                                    \
       V(ExternalUint64Array)                                                   \
       V(ExternalFloat32Array)                                                  \
       V(ExternalFloat64Array)                                                  \
     V(Closure)                                                                 \
     V(Stacktrace)                                                              \
     V(JSRegExp)                                                                \
+    V(WeakProperty)                                                            \
 
 #define CLASS_LIST(V)                                                          \
   V(Object)                                                                    \
   CLASS_LIST_NO_OBJECT(V)
 
 
 // Forward declarations.
 class Isolate;
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class Raw##clazz;
@@ skipping 75 matching lines @@
 // be dereferenced (e.g. RawSmi).
 class RawObject {
  public:
   // The tags field which is a part of the object header uses the following
   // bit fields for storing tags.
   enum TagBits {
     kFreeBit = 0,
     kMarkBit = 1,
     kCanonicalBit = 2,
     kFromSnapshotBit = 3,
-    kReservedTagBit = 4,  // kReservedBit{10K,100K,1M,10M}
-    kReservedTagSize = 4,
+    kWatchedBit = 4,

[Ivan Posva, 2012/08/14 00:26:39]

I was wondering whether you considered using the kFreeBit as this watched bit is
only used during marking and reset before sweeping. By definition you will not
be able to reach free objects, so you should be able to reuse that bit location.

[cshapiro, 2012/08/14 04:58:18]

This might be strictly true in old space but the usage of the free bit and the
watched bit overlaps in new space.  

[Ivan Posva, 2012/08/14 15:23:36]

We can consolidate the bits later, I was under the impression that I had changed
the scavenger to use the mark bit as well. Apparently not...

+    kReservedTagBit = 5,  // kReservedBit{10K,100K,1M,10M}
+    kReservedTagSize = 3,
     kSizeTagBit = 8,
     kSizeTagSize = 8,
     kClassIdTagBit = kSizeTagBit + kSizeTagSize,
     kClassIdTagSize = 16
   };
 
   // Encodes the object size in the tag in units of object alignment.
   class SizeTag {
    public:
     static const intptr_t kMaxSizeTag =
@@ skipping 50 matching lines @@
     ASSERT(!IsMarked());
     uword tags = ptr()->tags_;
     ptr()->tags_ = MarkBit::update(true, tags);
   }
   void ClearMarkBit() {
     ASSERT(IsMarked());
     uword tags = ptr()->tags_;
     ptr()->tags_ = MarkBit::update(false, tags);
   }
 
+  // Support for GC watched bit.
+  bool IsWatched() const {
+    return WatchedBit::decode(ptr()->tags_);
+  }
+  void SetWatchedBit() {
+    ASSERT(!IsWatched());
+    uword tags = ptr()->tags_;
+    ptr()->tags_ = WatchedBit::update(true, tags);
+  }
+  void ClearWatchedBit() {
+    ASSERT(IsWatched());
+    uword tags = ptr()->tags_;
+    ptr()->tags_ = WatchedBit::update(false, tags);
+  }
+
   // Support for object tags.
   bool IsCanonical() const {
     return CanonicalObjectTag::decode(ptr()->tags_);
   }
   void SetCanonical() {
     uword tags = ptr()->tags_;
     ptr()->tags_ = CanonicalObjectTag::update(true, tags);
   }
   bool IsCreatedFromSnapshot() const {
     return CreatedFromSnapshotTag::decode(ptr()->tags_);
@@ skipping 49 matching lines @@
   static bool IsByteArrayClassId(intptr_t index);
 
  protected:
   uword tags_;  // Various object tags (bits).
 
  private:
   class FreeBit : public BitField<bool, kFreeBit, 1> {};
 
   class MarkBit : public BitField<bool, kMarkBit, 1> {};
 
+  class WatchedBit : public BitField<bool, kWatchedBit, 1> {};
+
   class CanonicalObjectTag : public BitField<bool, kCanonicalBit, 1> {};
 
   class CreatedFromSnapshotTag : public BitField<bool, kFromSnapshotBit, 1> {};
 
   class ReservedBits : public BitField<intptr_t,
                                        kReservedTagBit,
                                        kReservedTagSize> {};  // NOLINT
 
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
     return reinterpret_cast<RawObject*>(
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
 
   intptr_t SizeFromClass() const;
 
   intptr_t GetClassId() const {
     uword tags = ptr()->tags_;
     return ClassIdTag::decode(tags);
   }
 
   ObjectKind GetObjectKind() const;
 
   friend class Api;
   friend class Array;
   friend class FreeListElement;
+  friend class GCMarker;
   friend class Heap;
   friend class HeapProfiler;
   friend class HeapProfilerRootVisitor;
   friend class MarkingVisitor;
   friend class Object;
   friend class RawInstructions;
   friend class RawInstance;
+  friend class Scavenger;
   friend class SnapshotReader;
   friend class SnapshotWriter;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(RawObject);
 };
 
 
 class RawClass : public RawObject {
  public:
@@ skipping 1114 matching lines @@
     return reinterpret_cast<RawObject**>(&ptr()->pattern_);
   }
 
   intptr_t type_;  // Uninitialized, simple or complex.
   intptr_t flags_;  // Represents global/local, case insensitive, multiline.
 
   // Variable length data follows here.
   uint8_t data_[0];
 };
 
+
+class RawWeakProperty : public RawInstance {
+  RAW_HEAP_OBJECT_IMPLEMENTATION(WeakProperty);
+
+  RawObject** from() {
+    return reinterpret_cast<RawObject**>(&ptr()->key_);
+  }
+  RawObject* key_;
+  RawObject* value_;
+  RawObject** to() {
+    return reinterpret_cast<RawObject**>(&ptr()->value_);
+  }
+
+  RawWeakProperty* next_;  // This field is owned by the garbage collector.

[turnidge, 2012/08/09 18:34:34]

Even more, it is only used during garbage collection.

[cshapiro, 2012/08/14 04:58:18]

Yes.  Removed.

+
+  friend class GCMarker;
+  friend class MarkingVisitor;
+  friend class Scavenger;
+  friend class ScavengerVisitor;
+};
+
+
 // ObjectKind predicates.
 
 inline bool RawObject::IsErrorClassId(intptr_t index) {
   // Make sure this function is updated when new Error types are added.
   ASSERT(kApiError == kError + 1 &&
          kLanguageError == kError + 2 &&
          kUnhandledException == kError + 3 &&
          kUnwindError == kError + 4 &&
          kInstance == kError + 5);
   return (index >= kError && index < kInstance);
@@ skipping 103 matching lines @@
          kExternalUint64Array == kByteArray + 18 &&
          kExternalFloat32Array == kByteArray + 19 &&
          kExternalFloat64Array == kByteArray + 20 &&
          kClosure == kByteArray + 21);
   return (index >= kByteArray && index <= kClosure);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_