Use a bit in the handle structure to indicate if it is a prologue weak handle instead of the taggin…

runtime/vm/dart_api_state.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_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/thread.h"
@@ skipping 187 matching lines @@
   RawObject** raw_addr() { return &raw_; }
   static intptr_t raw_offset() {
     return OFFSET_OF(FinalizablePersistentHandle, raw_);
   }
   void* peer() const { return peer_; }
   void set_peer(void* peer) { peer_ = peer; }
   Dart_WeakPersistentHandleFinalizer callback() const { return callback_; }
   void set_callback(Dart_WeakPersistentHandleFinalizer callback) {
     callback_ = callback;
   }
-  Dart_WeakPersistentHandle apiPrologueHandle() {
-    uword addr = reinterpret_cast<uword>(this);
-    return reinterpret_cast<Dart_WeakPersistentHandle>(
-        addr | kPrologueWeakPersistentTag);
-  }
   Dart_WeakPersistentHandle apiHandle() {
     return reinterpret_cast<Dart_WeakPersistentHandle>(this);
   }
 
   void SetExternalSize(intptr_t size, Isolate* isolate) {
     ASSERT(size >= 0);
     set_external_size(Utils::RoundUp(size, kObjectAlignment));
     if (SpaceForExternal() == Heap::kNew) {
       SetExternalNewSpaceBit();
     }
     // TODO(koda): On repeated/large external allocations for existing objects,
     // without any intervening normal allocation, GC will not trigger.
     isolate->heap()->AllocateExternal(external_size(), SpaceForExternal());
   }
 
   // Called when the referent becomes unreachable.
-  void UpdateUnreachable(Isolate* isolate, bool is_prologue_weak) {
+  void UpdateUnreachable(Isolate* isolate) {
     EnsureFreeExternal(isolate);
-    Finalize(isolate, this, is_prologue_weak);
+    Finalize(isolate, this);
   }
 
   // Called when the referent has moved, potentially between generations.
   void UpdateRelocated(Isolate* isolate) {
     if (IsSetNewSpaceBit() && (SpaceForExternal() == Heap::kOld)) {
       isolate->heap()->FreeExternal(external_size(), Heap::kNew);
       isolate->heap()->AllocateExternal(external_size(), Heap::kOld);
       ClearExternalNewSpaceBit();
     }
   }
 
   // Idempotent. Called when the handle is explicitly deleted or the
   // referent becomes unreachable.
   void EnsureFreeExternal(Isolate* isolate) {
     isolate->heap()->FreeExternal(external_size(), SpaceForExternal());
     set_external_size(0);
   }
 
-  static bool IsPrologueWeakPersistentHandle(Dart_WeakPersistentHandle handle) {
-    uword addr = reinterpret_cast<uword>(handle);
-    return (addr & kWeakPersistentTagMask) == kPrologueWeakPersistentTag;
+  bool IsPrologueWeakPersistent() {
+    return PrologueWeakBit::decode(external_data_);
   }
+
+  void SetPrologueWeakPersistent(bool value) {
+    external_data_ = PrologueWeakBit::update(value, external_data_);
+  }
+
   static FinalizablePersistentHandle* Cast(Dart_WeakPersistentHandle handle);
 
  private:
   enum {
-    kWeakPersistentTag = 0,
-    kPrologueWeakPersistentTag = 1,
-    kWeakPersistentTagSize = 1,
-    kWeakPersistentTagMask = 1,
+    kExternalNewSpaceBit = 0,
+    kPrologueWeakBit = 1,
+    kExternalSizeBits = 2,
+    kExternalSizeBitsSize = (kBitsPerWord - 2),
   };
 
   // This part of external_data_ is the number of externally allocated bytes.
   // TODO(koda): Measure size in words instead.
-  class ExternalSizeBits : public BitField<intptr_t, 1, kBitsPerWord - 1> {};
+  class ExternalSizeBits : public BitField<intptr_t,
+                                           kExternalSizeBits,
+                                           kExternalSizeBitsSize> {};  // NOLINT
   // This bit of external_data_ is true if the referent was created in new
   // space and UpdateRelocated has not yet detected any promotion.
-  class ExternalNewSpaceBit : public BitField<bool, 0, 1> {};
-  // TODO(koda): Use bitfield also for the prologue tag.
+  class ExternalNewSpaceBit : public BitField<bool, kExternalNewSpaceBit, 1> {};
+  // This bit is used to indicate that it is a prologue weak persistent handle.
+  class PrologueWeakBit : public BitField<bool, kPrologueWeakBit, 1> {};
 
   friend class FinalizablePersistentHandles;
 
   FinalizablePersistentHandle()
       : raw_(NULL),
         peer_(NULL),
         external_data_(0),
         callback_(NULL) { }
   ~FinalizablePersistentHandle() { }
 
-  static void Finalize(Isolate* isolate,
-                       FinalizablePersistentHandle* handle,
-                       bool is_prologue_weak);
+  static void Finalize(Isolate* isolate, FinalizablePersistentHandle* handle);
 
   // Overload the raw_ field as a next pointer when adding freed
   // handles to the free list.
   FinalizablePersistentHandle* Next() {
     return reinterpret_cast<FinalizablePersistentHandle*>(raw_);
   }
   void SetNext(FinalizablePersistentHandle* free_list) {
     raw_ = reinterpret_cast<RawObject*>(free_list);
     ASSERT(!raw_->IsHeapObject());
   }
   void FreeHandle(FinalizablePersistentHandle* free_list) {
     Clear();
     SetNext(free_list);
   }
 
   void Clear() {
     raw_ = Object::null();
     peer_ = NULL;
     external_data_ = 0;
     callback_ = NULL;
   }
 
   intptr_t external_size() const {
     return ExternalSizeBits::decode(external_data_);
   }
 
   void set_external_size(intptr_t size) {
+    ASSERT(ExternalSizeBits::is_valid(size));
     external_data_ = ExternalSizeBits::update(size, external_data_);
   }
 
   bool IsSetNewSpaceBit() const {
     return ExternalNewSpaceBit::decode(external_data_);
   }
 
   void SetExternalNewSpaceBit() {
     external_data_ = ExternalNewSpaceBit::update(true, external_data_);
   }
@@ skipping 181 matching lines @@
         free_list_(NULL) { }
   ~FinalizablePersistentHandles() {
     free_list_ = NULL;
   }
 
   // Accessors.
   FinalizablePersistentHandle* free_list() const { return free_list_; }
   void set_free_list(FinalizablePersistentHandle* value) { free_list_ = value; }
 
   // Visit all handles stored in the various handle blocks.
-  void VisitHandles(HandleVisitor* visitor, bool is_prologue_weak) {
+  void VisitHandles(HandleVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
             kOffsetOfRawPtrInFinalizablePersistentHandle>::Visit(
-                visitor, is_prologue_weak);
+                visitor);
   }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
             kOffsetOfRawPtrInFinalizablePersistentHandle>::VisitObjectPointers(
                 visitor);
   }
 
@@ skipping 217 matching lines @@
       scope = scope->previous();
     }
     persistent_handles().VisitObjectPointers(visitor);
     if (visit_prologue_weak_handles) {
       prologue_weak_persistent_handles().VisitObjectPointers(visitor);
     }
   }
 
   void VisitWeakHandles(HandleVisitor* visitor,
                         bool visit_prologue_weak_handles) {
-    weak_persistent_handles().VisitHandles(visitor, false);
+    weak_persistent_handles().VisitHandles(visitor);
     if (visit_prologue_weak_handles) {
-      prologue_weak_persistent_handles().VisitHandles(visitor, true);
+      prologue_weak_persistent_handles().VisitHandles(visitor);
     }
   }
 
   bool IsValidLocalHandle(Dart_Handle object) const {
     ApiLocalScope* scope = top_scope_;
     while (scope != NULL) {
       if (scope->local_handles()->IsValidHandle(object)) {
         return true;
       }
       scope = scope->previous();
@@ skipping 114 matching lines @@
           ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()) {}
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_